{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c8823310",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "间隔  501\n",
      "90% x轴坐标: 3544072\n",
      "50% x轴坐标: 949393\n",
      "95% x轴坐标: 4269520\n",
      "99% x轴坐标: 6291556\n",
      "间隔  320\n",
      "90% x轴坐标: 3334120\n",
      "50% x轴坐标: 922600\n",
      "95% x轴坐标: 4006760\n",
      "99% x轴坐标: 5805160\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#完整cdf\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    base_list=[]\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"      arrive\"):\n",
    "\n",
    "                flag=1\n",
    "                \n",
    "                continue\n",
    "\n",
    "            if str(base_line).startswith(\"the 0 channel,\"):\n",
    "\n",
    "                flag=0\n",
    "                \n",
    "            if(flag==1):\n",
    "                \n",
    "                if(len(base_line.split())!=7):\n",
    "                    \n",
    "                    print(\"error\\n\")\n",
    "                    \n",
    "                    print(base_line.split(),len(base_line.split()))\n",
    "                    \n",
    "                if(int(base_line.split()[3])==1):\n",
    "                    \n",
    "                    base_list.append( int(base_line.split()[6]))\n",
    "                 \n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return base_list\n",
    "\n",
    "def get_hist(latencys):\n",
    "    \n",
    "    #分割为1000份\n",
    "    max_latency=max(latencys)\n",
    "    \n",
    "    min_latency=min(latencys)\n",
    "    \n",
    "    granularity=1000000\n",
    "    \n",
    "    bins= math.ceil( (max_latency-min_latency)/granularity)  #ceil() 函数返回数字的上入整数。\n",
    "    \n",
    "    print(\"间隔 \",bins)\n",
    "    counters=[0 for i in range(granularity)]\n",
    "    \n",
    "    \n",
    "    for item in latencys:\n",
    "        \n",
    "        i= math.ceil( (item-min_latency)/bins)\n",
    "        \n",
    "        if(i<0 or i>(granularity-1)):\n",
    "            \n",
    "            print(\"overflow:\",i)\n",
    "        \n",
    "        if(i==granularity):\n",
    "            \n",
    "            i=i-1\n",
    "            \n",
    "        if(i==granularity+1):\n",
    "            \n",
    "            i=i-2\n",
    "            \n",
    "            \n",
    "        counters[i] = counters[i]+1\n",
    "    \n",
    "    sums=sum(counters)\n",
    "    \n",
    "    probability_counters= list(map(lambda x: x*1.0/sums, counters))\n",
    "    \n",
    "    #print(probability_counters,sum(probability_counters))\n",
    "    \n",
    "    probability_counters=cumsum(probability_counters)\n",
    "    \n",
    "    return probability_counters,[ (min_latency+i*bins) for i in range(granularity)]\n",
    "\n",
    "plt.rc('font',family='Times New Roman')\n",
    "mpl.rcParams['axes.unicode_minus'] = False #解决保存图像是负号'-'显示为方块的问题\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "tick_params(direction='in')\n",
    "ax = plt.gca()\n",
    "ax.spines['right'].set_color('none') \n",
    "ax.spines['top'].set_color('none')    \n",
    "\n",
    "base = get_trace_reference(\"HM_1_out_base\")\n",
    "gc = get_trace_reference(\"HM_1_out_gc\")\n",
    "\n",
    "ax=plt.subplot(1,2,1)\n",
    "y,x=get_hist(base)\n",
    "\n",
    "plt.plot(x,y,'b--',label=\"base\")\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)\n",
    "        \n",
    "        break\n",
    "\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break  \n",
    "plt.legend(loc='lower center') \n",
    "\n",
    "plt.ylabel(\"CDF\")\n",
    "\n",
    "\n",
    "ax2=plt.subplot(1,2,2) #两行两列,这是第二个图\n",
    "\n",
    "ax2.tick_params(axis=\"y\",pad=0)\n",
    "\n",
    "y,x=get_hist(gc)\n",
    "\n",
    "plt.plot(x,y,'r--',label=\"gc\")\n",
    "\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break       \n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break         \n",
    "\n",
    "\n",
    "plt.legend(loc = 'lower center') \n",
    "\n",
    "plt.suptitle(\"read latency of requests(unit:ms)\",y=0.05) \n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(\"readlatencycdf.pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "09ade280",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "间隔  6229\n",
      "90% x轴坐标: 7837910\n",
      "50% x轴坐标: 1384666\n",
      "95% x轴坐标: 41518113\n",
      "99% x轴坐标: 290516159\n",
      "间隔  2712\n",
      "90% x轴坐标: 7231723\n",
      "50% x轴坐标: 1376515\n",
      "95% x轴坐标: 11869243\n",
      "99% x轴坐标: 222182131\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    base_list=[]\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"      arrive\"):\n",
    "\n",
    "                flag=1\n",
    "                \n",
    "                continue\n",
    "\n",
    "            if str(base_line).startswith(\"the 0 channel,\"):\n",
    "\n",
    "                flag=0\n",
    "                \n",
    "            if(flag==1):\n",
    "                \n",
    "                if(len(base_line.split())!=7):\n",
    "                    \n",
    "                    print(\"error\\n\")\n",
    "                    \n",
    "                    print(base_line.split(),len(base_line.split()))\n",
    "                    \n",
    "                if(int(base_line.split()[3])==0):\n",
    "                    \n",
    "                    base_list.append( int(base_line.split()[6]))\n",
    "                 \n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return base_list\n",
    "\n",
    "def get_hist(latencys):\n",
    "    \n",
    "    #分割为1000份\n",
    "    max_latency=max(latencys)\n",
    "    \n",
    "    min_latency=min(latencys)\n",
    "    \n",
    "    granularity=1000000\n",
    "    \n",
    "    bins= math.ceil( (max_latency-min_latency)/granularity)  #ceil() 函数返回数字的上入整数。\n",
    "    \n",
    "    print(\"间隔 \",bins)\n",
    "    counters=[0 for i in range(granularity)]\n",
    "    \n",
    "    \n",
    "    for item in latencys:\n",
    "        \n",
    "        i= math.ceil( (item-min_latency)/bins)\n",
    "        \n",
    "        if(i<0 or i>(granularity-1)):\n",
    "            \n",
    "            print(\"overflow:\",i)\n",
    "        \n",
    "        if(i==granularity):\n",
    "            \n",
    "            i=i-1\n",
    "            \n",
    "        if(i==granularity+1):\n",
    "            \n",
    "            i=i-2\n",
    "            \n",
    "            \n",
    "        counters[i] = counters[i]+1\n",
    "    \n",
    "    sums=sum(counters)\n",
    "    \n",
    "    probability_counters= list(map(lambda x: x*1.0/sums, counters))\n",
    "    \n",
    "    #print(probability_counters,sum(probability_counters))\n",
    "    \n",
    "    probability_counters=cumsum(probability_counters)\n",
    "    \n",
    "    return probability_counters,[ (min_latency+i*bins) for i in range(granularity)]\n",
    "\n",
    "plt.rc('font',family='Times New Roman')\n",
    "mpl.rcParams['axes.unicode_minus'] = False #解决保存图像是负号'-'显示为方块的问题\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "tick_params(direction='in')\n",
    "ax = plt.gca()\n",
    "ax.spines['right'].set_color('none') \n",
    "ax.spines['top'].set_color('none')    \n",
    "\n",
    "base = get_trace_reference(\"HM_0_out_base\")\n",
    "gc = get_trace_reference(\"HM_0_out_gc\")\n",
    "\n",
    "ax=plt.subplot(1,2,1)\n",
    "y,x=get_hist(base)\n",
    "\n",
    "plt.plot(x,y,'b--',label=\"base\")\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)\n",
    "        \n",
    "        break\n",
    "\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break  \n",
    "plt.legend(loc='lower center') \n",
    "\n",
    "plt.ylabel(\"CDF\")\n",
    "\n",
    "\n",
    "ax2=plt.subplot(1,2,2) #两行两列,这是第二个图\n",
    "\n",
    "ax2.tick_params(axis=\"y\",pad=0)\n",
    "\n",
    "y,x=get_hist(gc)\n",
    "\n",
    "plt.plot(x,y,'r--',label=\"gc\")\n",
    "\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break       \n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break         \n",
    "\n",
    "\n",
    "plt.legend(loc = 'lower center') \n",
    "\n",
    "plt.suptitle(\"write latency of requests(unit:ms)\",y=0.05) \n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(\"readlatencycdf.pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "d0b6f271",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "间隔  6229\n",
      "50% x轴坐标: 1.384666\n",
      "90% x轴坐标: 7.83791\n",
      "95% x轴坐标: 41.518113\n",
      "99% x轴坐标: 290.516159\n",
      "间隔  2712\n",
      "50% x轴坐标: 1.376515\n",
      "90% x轴坐标: 7.231723\n",
      "95% x轴坐标: 11.869243\n",
      "99% x轴坐标: 222.182131\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "import matplotlib \n",
    "from numpy import cumsum\n",
    "\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    base_list=[]\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"      arrive\"):\n",
    "\n",
    "                flag=1\n",
    "                \n",
    "                continue\n",
    "\n",
    "            if str(base_line).startswith(\"the 0 channel,\"):\n",
    "\n",
    "                flag=0\n",
    "                \n",
    "            if(flag==1):\n",
    "                \n",
    "                if(len(base_line.split())!=7):\n",
    "                    \n",
    "                    print(\"error\\n\")\n",
    "                    \n",
    "                    print(base_line.split(),len(base_line.split()))\n",
    "                    \n",
    "                if(int(base_line.split()[3])==0):\n",
    "                    \n",
    "                    base_list.append( int(base_line.split()[6]))\n",
    "                 \n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return base_list\n",
    "\n",
    "def get_hist(latencys):\n",
    "    \n",
    "    #分割为1000份\n",
    "    max_latency=max(latencys)\n",
    "    \n",
    "    min_latency=min(latencys)\n",
    "    \n",
    "    granularity=1000000\n",
    "    \n",
    "    bins= math.ceil( (max_latency-min_latency)/granularity)  #ceil() 函数返回数字的上入整数。\n",
    "    \n",
    "    print(\"间隔 \",bins)\n",
    "    counters=[0 for i in range(granularity)]\n",
    "    \n",
    "    \n",
    "    for item in latencys:\n",
    "        \n",
    "        i= math.ceil( (item-min_latency)/bins)\n",
    "        \n",
    "        if(i<0 or i>(granularity-1)):\n",
    "            \n",
    "            print(\"overflow:\",i)\n",
    "        \n",
    "        if(i==granularity):\n",
    "            \n",
    "            i=i-1\n",
    "            \n",
    "        if(i==granularity+1):\n",
    "            \n",
    "            i=i-2\n",
    "            \n",
    "            \n",
    "        counters[i] = counters[i]+1\n",
    "    \n",
    "    sums=sum(counters)\n",
    "    \n",
    "    probability_counters= list(map(lambda x: x*1.0/sums, counters))\n",
    "    \n",
    "    #print(probability_counters,sum(probability_counters))\n",
    "    \n",
    "    probability_counters=cumsum(probability_counters)\n",
    "    \n",
    "    return probability_counters,[ (min_latency+i*bins)/1e6 for i in range(granularity)]\n",
    "\n",
    "base = get_trace_reference(\"HM_0_out_base\")\n",
    "gc = get_trace_reference(\"HM_0_out_gc\")\n",
    "y,x=get_hist(base)\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break\n",
    "\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)    \n",
    "        break\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        val_x=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)        \n",
    "        \n",
    "        break  \n",
    "index = x.index(val_x)\n",
    "x1 = x[index:]\n",
    "y1 = y[index:]\n",
    "\n",
    "y,x=get_hist(gc)\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        break\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)\n",
    "        \n",
    "        break    \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        val_x=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)\n",
    "        \n",
    "        break         \n",
    "\n",
    "index = x.index(val_x)\n",
    "x2 = x[index:]\n",
    "y2 = y[index:]    \n",
    "\n",
    "\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "tick_params(direction='in')\n",
    "ax = plt.gca()\n",
    "#ax.spines['right'].set_color('none') \n",
    "#ax.spines['top'].set_color('none')    \n",
    "ax.spines['top'].set_visible(True)\n",
    "ax.spines['right'].set_visible(True)\n",
    "plt.ylabel(\"CDF\")\n",
    "plt.xlabel(u\"写请求延迟(单位：毫秒)\") \n",
    "plt.plot(x1,y1,'b',label=\"BaseLine\")\n",
    "plt.legend(loc='lower center') \n",
    "\n",
    "\n",
    "plt.plot(x2,y2,'r',label=\"LA-GC\")\n",
    "plt.legend(loc = 'lower center') \n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(\"write.pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "50d3bec0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "间隔  4675\n",
      "50% x轴坐标: 0.10385\n",
      "90% x轴坐标: 0.96405\n",
      "95% x轴坐标: 1.9832\n",
      "99% x轴坐标: 192.774625\n",
      "间隔  1557\n",
      "50% x轴坐标: 0.100648\n",
      "90% x轴坐标: 0.819982\n",
      "95% x轴坐标: 1.478593\n",
      "99% x轴坐标: 90.325684\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "import matplotlib \n",
    "from numpy import cumsum\n",
    "\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    base_list=[]\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"      arrive\"):\n",
    "\n",
    "                flag=1\n",
    "                \n",
    "                continue\n",
    "\n",
    "            if str(base_line).startswith(\"the 0 channel,\"):\n",
    "\n",
    "                flag=0\n",
    "                \n",
    "            if(flag==1):\n",
    "                \n",
    "                if(len(base_line.split())!=7):\n",
    "                    \n",
    "                    print(\"error\\n\")\n",
    "                    \n",
    "                    print(base_line.split(),len(base_line.split()))\n",
    "                    \n",
    "                if(int(base_line.split()[3])==1):\n",
    "                    \n",
    "                    base_list.append( int(base_line.split()[6]))\n",
    "                 \n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return base_list\n",
    "\n",
    "def get_hist(latencys):\n",
    "    \n",
    "    #分割为1000份\n",
    "    max_latency=max(latencys)\n",
    "    \n",
    "    min_latency=min(latencys)\n",
    "    \n",
    "    granularity=1000000\n",
    "    \n",
    "    bins= math.ceil( (max_latency-min_latency)/granularity)  #ceil() 函数返回数字的上入整数。\n",
    "    \n",
    "    print(\"间隔 \",bins)\n",
    "    counters=[0 for i in range(granularity)]\n",
    "    \n",
    "    \n",
    "    for item in latencys:\n",
    "        \n",
    "        i= math.ceil( (item-min_latency)/bins)\n",
    "        \n",
    "        if(i<0 or i>(granularity-1)):\n",
    "            \n",
    "            print(\"overflow:\",i)\n",
    "        \n",
    "        if(i==granularity):\n",
    "            \n",
    "            i=i-1\n",
    "            \n",
    "        if(i==granularity+1):\n",
    "            \n",
    "            i=i-2\n",
    "            \n",
    "            \n",
    "        counters[i] = counters[i]+1\n",
    "    \n",
    "    sums=sum(counters)\n",
    "    \n",
    "    probability_counters= list(map(lambda x: x*1.0/sums, counters))\n",
    "    \n",
    "    #print(probability_counters,sum(probability_counters))\n",
    "    \n",
    "    probability_counters=cumsum(probability_counters)\n",
    "    \n",
    "    return probability_counters,[ (min_latency+i*bins)/1e6 for i in range(granularity)]\n",
    "\n",
    "base = get_trace_reference(\"HM_0_out_base\")\n",
    "gc = get_trace_reference(\"HM_0_out_gc\")\n",
    "y,x=get_hist(base)\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        label=i\n",
    "        \n",
    "        break\n",
    "\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)    \n",
    "        break\n",
    "\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        val_x=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)        \n",
    "        \n",
    "        break  \n",
    "index = x.index(val_x)\n",
    "x1 = x[index:]\n",
    "y1 = y[index:]\n",
    "\n",
    "y,x=get_hist(gc)\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.5)<0.01 or  j>0.5):\n",
    "        \n",
    "        print(\"50% x轴坐标:\",i)\n",
    "        \n",
    "        break\n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.9)<0.01 or  j>0.9):\n",
    "        \n",
    "        print(\"90% x轴坐标:\",i)\n",
    "        \n",
    "        break    \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.95)<0.01 or  j>0.95):\n",
    "        \n",
    "        print(\"95% x轴坐标:\",i)\n",
    "        \n",
    "        val_x=i\n",
    "        \n",
    "        break        \n",
    "for (i,j) in zip(x,y):\n",
    "    \n",
    "    if( abs(j-0.99)<0.01 or  j>0.99):\n",
    "        \n",
    "        print(\"99% x轴坐标:\",i)\n",
    "        \n",
    "        break         \n",
    "\n",
    "index = x.index(val_x)\n",
    "x2 = x[index:]\n",
    "y2 = y[index:]    \n",
    "\n",
    "\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "tick_params(direction='in')\n",
    "ax = plt.gca()\n",
    "#ax.spines['right'].set_color('none') \n",
    "#ax.spines['top'].set_color('none')    \n",
    "ax.spines['top'].set_visible(True)\n",
    "ax.spines['right'].set_visible(True)\n",
    "plt.ylabel(\"CDF\")\n",
    "plt.xlabel(u\"读请求延迟(单位：毫秒)\") \n",
    "plt.plot(x1,y1,'b',label=\"BaseLine\")\n",
    "plt.legend(loc='lower center') \n",
    "\n",
    "\n",
    "plt.plot(x2,y2,'r',label=\"LA-GC\")\n",
    "plt.legend(loc = 'lower center') \n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.savefig(\"read.pdf\", bbox_inches = 'tight')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "35ad6947",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    x = []\n",
    "    y = []\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"      arrive\"):\n",
    "\n",
    "                flag=1\n",
    "                \n",
    "                continue\n",
    "\n",
    "            if str(base_line).startswith(\"the 0 channel,\"):\n",
    "\n",
    "                flag=0\n",
    "                \n",
    "            if(flag==1):\n",
    "                \n",
    "                if(len(base_line.split())!=7):\n",
    "                    \n",
    "                    print(\"error\\n\")\n",
    "                    \n",
    "                    print(base_line.split(),len(base_line.split()))\n",
    "                    \n",
    "                if(int(base_line.split()[3])==1):\n",
    "                    if(int(base_line.split()[6])!=1000):\n",
    "                        x.append(int(base_line.split()[4])/1e9/3600)\n",
    "                        y.append(int(base_line.split()[6])/1e6)\n",
    "    file_base.close()\n",
    "    \n",
    "    return x,y\n",
    "\n",
    "mpl.rcParams['axes.unicode_minus'] = False #解决保存图像是负号'-'显示为方块的问题\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "tick_params(direction='in')\n",
    "ax = plt.gca()\n",
    "    \n",
    "\n",
    "x1,y1 = get_trace_reference(\"HM_0_out_base\")\n",
    "x2,y2 = get_trace_reference(\"HM_0_out_gc\")\n",
    "plt.plot(x1,y1,'b--',label=\"BaseLine\")\n",
    "plt.plot(x2,y2,'r--',label=\"LA-GC\")\n",
    " \n",
    "plt.ylabel(\"读请求延迟（单位：毫秒）\")\n",
    "plt.xlabel(\"时间（单位：小时）\")\n",
    "plt.legend(loc = 'best') \n",
    "plt.tight_layout()\n",
    "plt.savefig(\"op_read.pdf\", bbox_inches = 'tight')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "922826bb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    x = []\n",
    "    y = []\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"      arrive\"):\n",
    "\n",
    "                flag=1\n",
    "                \n",
    "                continue\n",
    "\n",
    "            if str(base_line).startswith(\"the 0 channel,\"):\n",
    "\n",
    "                flag=0\n",
    "                \n",
    "            if(flag==1):\n",
    "                \n",
    "                if(len(base_line.split())!=7):\n",
    "                    \n",
    "                    print(\"error\\n\")\n",
    "                    \n",
    "                    print(base_line.split(),len(base_line.split()))\n",
    "                    \n",
    "                if(int(base_line.split()[3])==0):\n",
    "                    if(int(base_line.split()[6])!=1000):\n",
    "                        x.append(int(base_line.split()[4])/1e9/3600)\n",
    "                        y.append(int(base_line.split()[6])/1e6)\n",
    "    file_base.close()\n",
    "    \n",
    "    return x,y\n",
    "\n",
    "mpl.rcParams['axes.unicode_minus'] = False #解决保存图像是负号'-'显示为方块的问题\n",
    "plt.rcParams['xtick.direction'] = 'in'\n",
    "plt.rcParams['ytick.direction'] = 'in'\n",
    "tick_params(direction='in')\n",
    "ax = plt.gca()\n",
    "    \n",
    "\n",
    "x1,y1 = get_trace_reference(\"HM_0_out_base\")\n",
    "x2,y2 = get_trace_reference(\"HM_0_out_gc\")\n",
    "plt.plot(x1,y1,'b--',label=\"BaseLine\")\n",
    "plt.plot(x2,y2,'r--',label=\"LA-GC\")\n",
    " \n",
    "plt.ylabel(\"写请求延迟（单位：毫秒）\")\n",
    "plt.xlabel(\"时间（单位：小时）\")\n",
    "plt.legend(loc = 'best') \n",
    "plt.tight_layout()\n",
    "plt.savefig(\"op_write.pdf\", bbox_inches = 'tight')\n",
    "plt.show() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8e87930e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXsAAAEECAYAAADJSpQfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABVqUlEQVR4nO29eZwUxf3//3rPHiz3udwiKpcgh4iACCoioMFbJKjxNmiMRo3Rn+dXoiF4JybReAclHtFP1KgIKAICiiAIqChesMihyH0tC7s79fujp2f6qOqu6umemZ2p5+PBg9nu6qrq7qp3v+td73oXMcag0Wg0mvwmlu0KaDQajSZ6tLDXaDSaAkALe41GoykAtLDXaDSaAkALe41GoykAtLDXaDSaAqA42xXg0apVK9a5c+dsV0Oj0WjqFEuXLt3CGCvnnctJYd+5c2csWbIk29XQaDSaOgURrRWd02YcjUajKQC0sNdoNJoCQAt7jUajKQBy0mbPo7q6GuvXr0dVVVW2q6IRUFZWho4dO6KkpCTbVdFoNA7qjLBfv349GjdujM6dO4OIsl0djQPGGLZu3Yr169fjkEMOyXZ1NBqNgzpjxqmqqkLLli21oM9RiAgtW7bUIy+NJkepM8IegBb0OY5+PxpN7lKnhH1dZu7cuaioqPA9lg5vvvkmBg4ciKFDh2Lfvn0AgOnTp2P69OmhlaHR5BsHauK49bXP8POu/B6VamGfITIh7N944w288MILWLBgAerXrw8AOOWUU3DKKaeEVoZGk2+8/9UmvLR4He56c2W2qxIpWthLUlVVhdNOOw1DhgzB2LFjUVNTg6qqKowfPx7HHHMMTj/9dOzbtw979+7FmDFjcNxxx+HSSy8FAFx00UV49tlnce2112L8+PHCY5s2bcLJJ5+MQYMGYfLkyQCMD8Lvf/97jB07FnfccYewfqNGjcK0adNw/vnn44YbbkgenzJlCqZMmZL8+z//+Q/69++Pk046CePGjUNFRQVOOOGE5Hnz95QpUzBp0iSMHj0ajz32GABj5DB48GAMHDgQK1asSPuZajS5QKHs1VdnvHGs/PGtlfhy465Q8+zZvgnuOq2X8PzKlStBRPjoo48wY8YM7NmzB88//zz69u2Ll19+GU8//TQ+++wzNG/eHFdeeSVGjRqF0aNHY9OmTXj++ecxceJEnHDCCUlhyjs2efJkjB8/HpdccgkGDx6MCRMmADAE9Ny5c9G1a1dh/d59911ccsklmDhxIrziCr344ot46623MGXKFPTo0cMz7UsvvYTZs2ejdevWiMfjuP7667Fs2TKsXbsWEydOxGuvvSa8VqOpKxTKzqx1Uthng/79+6N379447bTTcOihh2LEiBFYtWoVzjnnHADAZZddBsYYNmzYgKlTp2Lq1KnYsWNH0nYuw9dff42FCxdiypQp2LNnDzZu3AgAOO+88zwFvQp9+vTB+PHj0bJlS1xzzTWu89b6XnXVVWjdujUAYPPmzdi6dSvOOOMMAEC9evVCqY9Gkyvku39BxoQ9ERUDeAlAewBfM8YuC5qXlwYeFcuXL8fgwYMxadIkXHDBBZg3bx569OiBRYsWYcSIEZg0aRLatWuHtWvX4swzz8S4ceNw/PHHJ6+vX78+9u7dC8DwSSci17Hu3bvjjDPOwPDhwzFlyhQ0b94cW7duRaNGjUK7jy+++ALz58+3HTtw4AAYY9i4cSM+//zz5HFrueXl5ejWrRtmzZqFyspKm2lIo6nLsAIx5GTSZn8mgBWMsWMBtCOifhksO20OOeQQ/P3vf8fAgQOxceNGDBgwABMmTMDy5csxdOhQLFu2DL/61a8wcuRITJo0CSNGjAARJbXzc845B5MnT8agQYOwevVq7rFbbrkFDzzwAAYPHoxZs2ahbdu2od9HcXExjj766GQ9AeD000/HuHHjMHnyZBx++OHc62KxGG6//XYcd9xxOP7441Fezo2iqtHUWQj5rdoTy5DBiogaAYgDOABgPoALGGOreWkHDBjAnCGOv/rqK6Eg0shRVVWFUaNGIRaLoXHjxigvL8ezzz4bahn6PWnqGm+t2IhrX1qGMb3b4dEL+me7OmlBREsZYwN45zJmxmGM7UlUZhGAH0WCXhMdZWVlmDdvXrarodHkJvmt2GfOjENELYmoHoAhAJoT0XDH+QlEtISIlmzevDlT1dJoNJqCIJM2+xsBnMsYqwVQCaC+9SRj7EnG2ADG2ACRPThTJidNMPT70dRFCqXVZlLYPwrgMiJaCGArgJkqF5eVlWHr1q1aoOQoZtTLsrKybFdFowlEnltxMmqz3wDgxKDXd+zYEevXr4c28eQuZjx7Te4SjzOM/us8XHdSV5zap322q5MTFIoCWWcWVZWUlOg46SHBGMM/Zn+HM4/sgINaNMh2dTQZZH9NHN/+vAd/eHWFFvYO8j1qq46NU4Cs374PD733DS6b8km2q6LJMOYConz3Kde40cK+ADFHrVU1tdmtSIj8vKsKd7/1JWpq49i5rzrb1clZCsRiEYh8//zVGTOORuPFba9/jllf/YwGpUX4x5zv8PRFA3BSzzbZrlbOYcr6PLdYKFEoH0Ct2Wvygpq40WM//WE7AODj1VuzWZ2cxZyM1LLeTb5/ALWw1+QFZj81tbQCUdaUSWn2cpJtz/4a/eHME7SwL0DyMcpfvntSmOw7UIvLp3yCddsqA11vfgxln9Z1Ly3D+Cc/xpY9+wOVVxfIx/7AQwv7AiYfPTLyveO+v2oT3l/1MyZP/yrQ9UxR2q/6aTcAoKo6fybzReRfb7Cjhb3GxvxvN2NTHdx42WnGyXeCfqjjipp9IVAobUYLe42NC59ZjNP+viDb1VDGtOLke79NVzDFExnEYlrcO8l3U6AW9hoXP++ui/ZZe0ctFG1Nlbj2xnFRKG1FC3uNppAoEMEWhHz/AGphX4Ak5+jyqHUn76VQhFnAd5e02efTy0+TZJPJ80eihX0BkvS1Dnj93v01qNiyN6zqhEKe99Mk6X7Lgppx6qKp4/Vl67F3f41vutRCs/xuRVrYa5S55F+LccKDc7NdDRupCdo6KJUCEFQsJYV9fss1LPthO274zwrc8cYX2a5KzqCFfZZZvz3Y4pgwqNhaierauPJ1n1Rsj6A26WFqZakVtP5Cf8OOfVjw7ZYoqxUq8ThLO/Y6KxCbxd79xroAGTfiwlAPtLDPKvO/3Yyh983B259tzFodHnr3m6yVnW1GPvwBfvXMomxXQ5pDb3sHE99cCSC4zT3ofE1dHQmo1Luu3qMsWthnkVU/GqsTl/2wI2t1+HbT7qyVHSZmR40r2F8rD9S9VaHbK9ML36xdLzkUiGqvhX0WMRe2xDMw+1V5oAbD7p+NRavD28c3l7ZzK5RFVSZvrdiIkQ9/oHxdUJt9Dr1qX/67dD2++1ldicn3D6AW9lnEXMSYiY701Y+7sW7bPtw7Y5UwjarwjueQAMh3Twreu/n25z3K+aTCJeTX8/px5z6s3Wp4iN346gpMfOtL6WsLZVJfC/ssEkuoV7UBpSZjDAdq1CdYbXnY8lMvP1cRdeC6uotVeI86P71xjpk8G8c/MDetPPLtmTjJmLAng+eI6GMiepOICn6XrHTNOFM/Xotud0xXDlwWltzIJc0eEqOkpWu3oe8f38XMlT9lpk45SNBAaLkmCBlj2CkxfyEzgslhnSVUMqnZHwugmDE2GEATAKMyWHZOEktOKga7/n/LDS8e1djm1sZt7Qqq1cjEXIMsMgtoP1u/EwDw0Xd1x93SJLwPtKnZq0nvHHrVAAxFp+/d72JNiIv7ojJtTZr2JW74z3LbsVU/7cJzH1VEUp6ITAr7TQAeSfw+kMFycxbTjBNPw4yjfo34OtX8ckkAJIWXR6XqckSFsExm8fSsfjnD+1/9DACo2Oot7IOOSHbuqw68QYyTp+avwevLNtiOnfLIfNyVcKPNFBkT9oyxbxlji4noLAClAGZmquxcpYjC8caRadDWNKLSVGuRSxNbMn3a/CDIPu7KAzX4eXcVrn5haSDvjiBUVdfi+AfmRLbYi9Uhm31tnOHKqUuS+wpbCavlMca47qxj/jYfw+6fE1IpvHIjy1pIRidoieh0ANcBOI0xVus4N4GIlhDRks2bN2eyWlnD7HDTPv8RP+3MzIYhDOE1tFyy2TtdL3n3mPR+khQVIx+eh4GT3sc7n/+Em//vs/QrKUHF1r1Yu7US97xt9yYJT7gZ/9cFYf/jzn2YuXITrn1xmTBNurfx5LzVuC/hoWZ9Juu370szZzky6eSQyQnatgBuAjCGMeZSkxhjTzLGBjDGBpSXl2eqWlnFNONUHqjFL59cKHXNswvW4PEPvgegJgDstvnUlWssw2DVdpeLNnvvRGqa/YYdqQ6f7Q9beB/ouhf0K0qBaJqDskVQT7wgZFKzvxhAOwAziWgBEV2WwbJzkpjl6W9IaBIffLMZLy/+QXjN3W9/iXunO33lg0+2rd68F9M//9E4rqg/shy0/8rIhSDdK3c+a+kRr0OafdLsxjkXxQcgG8+kNh81e8bYfYyxLoyxoYl/z2aq7FwlZmld5iu/+NnFuOW1z6Wul2knNbVx+wQwY67rvk6ETODlt3d/Deas4ms/OWWzTwoGcZ2si9isz0RKcGSoU4qKUX3WB2riuOK5JVj10y7b8boU4lhmX+G04/Jn+aO3dmtlxkKW6EVVWcQm7CPqTV1un46z//mRrVM4BUdZSZHw+lte+xyXTvkE3292r9bMtmnDitQEbTIyJsM901I2cZlHn+17VW0en2/YiVlfbcKtDsUhZbM3nsXcr39G51umYcse760os/Fhz3zY6sxL/lF/mYeRf5mXkbK0sM8isQyNG5ev22H72yk4yorFzWDNFkPI8zaBCNtmv2bLXnzwTXST81bvzFc+WZc8LnMfZpr12ytREyAstCzhNQlv91qzmGc/rAAAfLFhp3duabzqc/75Ed5coR7ZNRPzCkFCfIdBNvZ718I+i4T1wtMVEKZmz+vQzjjxVsIW9sMfnIuLn10c7GKJFbRWbxzimNCsvOtYZcsYsLOyGkPvm4OJb0XvH/11SEN7Z9NIjlDIfj5KM83Stdvxu5fEHjV+qNTNOUL2M/NYI86G8aH914drMO5xf2eLbGwLqYV9FonFvAWOH0H7p7Pz1CuJJfJz5+jZJrNs2rBu5uH1UTIx08SZwzuJc82qn+zCNs4Y9tcY3sIzvthkO3ftS8vQ+ZZpirXnY63LPksI5jCE8TebdmPcE4YgMu9f1h01qle9cuNOfPQ9f01BkEimbucFMc4Pw4uLfvB0jpDhj299icUV23zTac0+YmrjDI/M+ha7qnIjGJaMGefn3VVpBzuzwsCx2ReLbfZexBmwZ38NKg/47/Pp5O3PNqYVo6Y2znDobe8kO7eUomTV/i3peSMUXnZFiR66z3G/bwUwUWSD975MfaRMzTK1itv72qBzSn7XjfnbApz/FH8DGeuo453Pf8RD737tW94T81Zz8+DXzX1M1jkiXbRmHwELvt2ClRsNe+TMlT/hL7O+wZ+nfZXlWsnBGMPASe/jhleWp52XtWk5JxtLEzZ7r35pPWXdKOSIu2ai393vKdfnmheX4cqpS5WvMzFtrf9KxBeRCYUQs3js+HU1Z19kLPXcKqvD3fTk7Mc+xBn/WOCZRqR5v7T4BwyZ/L5UOVYPJPP2nJu+iLjhP8vx2qfrpcqxks6IxOIvhatf+BR/n/2dK990RGaUbo9+G51rzT4CfvXMIoz5m9GRTAGxN0d2KPLSevbur8GeRIOZ8YVAAw7sRsccfyf+56RNaVduQWEKCNHIY+rCCmze7e3lERTrLbz26Xq8unS9rZ68Z2vVFG02e95chUPaxxlLCtywZcSnP+zAikSQNpHCJyrz1tc+x8YAq6/XbqvE1I/XevqyW1mxfid+/8oKqbznrPo5GeTLmS9jDN9JxuGP2t0zykWBve6aiR+2imPrZMo5w0pBhhnOlTjs1lo4q9Trrplo3qAEQMp8IEI5gqHg70nTOBs+eOTt9RhXb96DO/+3Em+t+BGvXHWMUv1kqLV86GSFkPVWrL+5ZhzHbcc56xMySRhFW/M4UBPHnW98gZMOb22cC/HmLp3yCQDg4iGdXfk+PX8NJr1jjKz7dGzqU1//j6tf0/c6H3VQuDVb9+KgFvW557Ih7PNes7cSk9RiMoVf/zIDNBUJGkZYE7Rmh3xp8TpOajcyAcWqa42T2yujCXAaZJl5yvXSbsbhj2jsz5whM+EhrEWo+JfLCGuvEUxU6wic2S5btz352ww5Lbw2hzT7eJzhwmcWKbkGM8bw/MK13HPajBMx1s6eG8jVw0+zl7mfxWu2JdK6y1V9Gk4zDrdOEUdXDBIW2uaN47OgzfnIjdDQykV68tS81Zi9apN/Qvi/Y7kwEWLTVlQfMrdiIX+tWSfrJas370FNbTythVY791VjZ2W1ks2+qqYW87/dgqsU55lWrN/BPR7LgrQvKDOO1T1vz/4afLZ+B4Yc1ipr9ZFta77C3vJ7+uc/ommDEtd9mUNnXrne7ooG87/dgiM7NTeOSU7qGddH06hFHVVmyD/t8x/RtH5J8jjvu+EcZjPGQheI1nfCw67leyNTM88J+Mg0++AZJ+eSLJU78aEPcNmxh6RVp75/fBcAsOL/hbd/UlV1rWsluoyzQCYpUM0euP7lZTj/qUX4eXdmQgvzkO0G/pp96vdvXvhU6MomKpcxJtQczWf28HvfuCZiveoflfB4/6tNmL1qU1KzF05ouurD8MQHhltebdzhjcM1b9j/jkeg2fuhUpyUGYdzTOXDHYQosv149dZQ8lG5Z6+kb63YiB53zsA3zoVwTKzsZMOMk7ea/bptlWjZqDT59/0zViUnhA7UxjE7Edyr6oDaLI1pK/YTwDKkq9nzNJ8g5TKkbOxemPduNGDxB8JK2ArM5c8tAQAsvPVE7nmRJvlJxXZ8+WMqKJh9Mxf/+8jGBK31+fqVLVU1roeS9/xLmO+v5/+bgUoFTziRl5hVSPuNHL3OBnG95D2PWV8ZpjjTxdsvvXFca/ahMez+ObjomdTS+8fmfg/z1afjDjjsvtnoPTGcTbZkh7jFCmYcqXI5rpfm6lAvakz3haQ26FWGYqUUEU3Qisp1x7NJPVM5M07m4/cz4R+ctFI2e69z6mYxGazXqwh6QOyNE9b8STb3Y+B16cnTvxKuJg6lzMhyzgGWrN1u+9vsv1WWRTGqNsWNO6uUG62IsGz2KpOVjHPHDAz7Bb7y1pJrapntWDY7S+q74/aasbJuWyUufnYxd+u55DUSrpdAOPf76pJ1vkHHTFSKc75V3rV8bxzjf/N57jtQ67sgSIWwbfZAsPdw/cvLcMcb9tWxKq6XQe7CO9y2u4E98cFqXxNsOuStGYeH+XhFgi1MPvhmM3q0bYw2TcqEaUKz2SvUC3B3FkOzFwh7S6OscXxUvDpLyhsnmuGqbIe/8dUVWLxmG7q1aSS8nmvL5pQXhnviTYntDSvuHcM9b7st2wStmjcOr65eeZhnBv55FnZX1Qjr58U5//wITcrsIiWMFbRu5cT627sAs/29sdwIafGnM3snz6nZ7MVpg7Rwp7D/eVf0c4d5rdk7MR+wTbOPSDm9+NnFOPPRDz3TyNraxX72xvXKmg7HZi8Tf8c048jEGTerRAAmPL8kGeJ2y579rg01gpBcVOVykTSOr9y4C7urDBc7AGhQahdC2/am/P95z8/pGsdzWVVFbhKV8X8rFp3cpMRnpbAz/e4qu1av8q1eunY75nxt90NP54mJnpd1/iSd/quyViNuac8qiNI7n+vAP8uFvEiHvBT2fp4ldjNOdOX/GNIm4r6TwenJejDG5Gz2STOO/6IqK+9+uSkZ4nb4g3Nx8l/nS9dVhMh0ZR5dunY7Lkus5AR8BC3PvOEsLwTNXsb8F1R4OT9Y1h2pJr65Eh+v3urpjaMi+GrjzNaHvJBVaF5c9IMrPhBz/TDz5KQJgEzVkkpQgIIYE38stetlSIgablLYR2DGmbqwAje9aizbd5o7RMhq5Kawt7p2WTuRqhDiFVsj8Max2ewd7o5SfvaWDHZWVrs0x6BYwyWI+KRiu5Rmyr0LV2yc9G32pi3cq042QWb5/dT81e7Eguucf0/5qALjn/yYb7NPPEFRm+Vdc9W/l6LHnTMw4E+zsMNnhbTsE7vt9c+T8YEA4IVFa3FFwvPKmUfc1vZ9zDge52S8ca558dNEHSRGZQrNQ6+gDQmR8DMbttVkEdZq2jv/tzIZjEskOJ2oTNC+tWIjRlm2L7P6fStvFM6ZzJNxvatNmHHM+1P9yPS9+13XsaWOSXSjPu6Mq2vjtljjQk1U7TAAgRnH1RnTd73cnRD2DUvFU2V2M04Kw5tMjDXtNS9+ijeWbQDgnJsQ30Ctwo5NZqjkLXv2Y9Ea79jtQZ/Z7a9/gTVb9iby4I9aAGD15r3471L1aJzOfES8m7jX1Ym68OagZOelGGPJcOA6EFpICF8i18Mi/PKrPWYu43GGmjhDaXFMSdg77dxWYafktcER7IaJwj+T6lqGDTv24UBCMLy5XBzH3czO7/me88+PXJOBcQYUOd7VEx98jwff/SaVxvTGcbpI+tRH9pyzM+6orMY+i+mi8kCNax7AD1Ozb1hPvH+AXbMPNoH49mc/Jn/bNHauHYeTTgHfKobQv9xmx9SH6563OcH7ZPMVVJ63VeHZj30UIH+7t9jcrzfj0imf4NWrjoksjIgXGdXsiaiEiN6Kuhyh4OIcjsJ90EuznzB1KbrdMV1UHS4lRe7XZJ2k4t2Dlzsmv/P4U1PL8L0lPO2zH65J/r53+iquHTdIDBuzEy5esw0/7twHANiyx24uUF0Q4x3Hx42zL9bEGcb+M9Xh73lbfU8E0+OJ9z5NeF5CMnveiu7OuljOubGH9ULR8/EXSt7vIYrNwsPqsqLHao6KVHGZ0hznF3xn+NAvqdie34uqiKg+gKUARkZdlki+cIWiRMupqY372iad6UWYq+0Aec2tOEauhmTT7DnXiO5r3bZK96Iqj/RWzaTGY8Ty+AffY6olwp/ZyYOsUjRvbdwTCzHq4XncNKnVvHZEz9TTjMNpMHw/+9TvIAvzkh5KXjZ7Tvp9EpOhosdc6+NMnvLo8i0iEFF4u6koaO8nVsqr5OPlmp2OiDbb7H0zVmHnvszvlpcxYc8Y28cY6wMgmIFNAdFL5DVoGS+Eu95ciX53vyftgVAt2XNkm6y5k5QVqxDlCTjDpu8+vquqRhAbR1C4pXX7DfVrOKalQJq9pYamnVt2YY3zaCqEr1o9/DSvIIqZOUrxwu5pYvyxT2YRn+D2/OaPvEaHMvhdFoas55kdwyBImGwVGGO2dmLOQQDpreIPSn5O0ApeIq+RyLQb00f8/hn+e2ACcsNuo3C5ZFwzjo/N3stVkKfZy4wyamq9B+XFnA3Ug9iCeVVxHkp2VEmh6yX0+F4q3vDOV2zZi7Vb93LOGFz38nKfXAHrnZqB26RcNgVvxmv+CLBM8nMu/2Frpavsv7z3je1vv9cbhgOE897SCUpnrc/Ln/A3F5fJ+pRH5uOVJcb+D7LffZVY+FGQM8KeiCYQ0RIiWrJ5c3oPRSzk3MdUvu5WG7UXMkHFAHl7ZolztjJRhnk1d7WkQLMHOLZKWZu9j+DgxegOoj1xhb1Tu5N0FTRr5PUB5u9Upa66n/DgXBz/wNykcqDKhh37bPV/ZoHR3tIy4/hp9qYZh/M8j3tgjm3xGQA88v63vnWx558+brdStVxvez0VJsG6mchrnwps8175J5rFVz/uws2J1dAmNyZcr23JszARKyJnhD1j7EnG2ADG2IDy8vK08hIJGN5xqSGhYov1E4rJbB35igRSSVFMrNlCZMYRa/aucAlgQuHp9LP36mjWb5KZLpCw5zxw5zGRn70zndnZvEYY1jMffb8F73z+ozCtDOYCMhGiSI3H3jvb9c4Yk1vAJLo7P5OieTqoRUM1jIMfi31cOYPk+eKilAa/aI1/eGS/7GVNk9EaidTJGWEfJiKBxBPCYXvjTP14rU1jGP/kQnGERsff981YxU3HM+NY3cN42Xu5Uzobq5c3jlUz8bP/FhXFsG5bpS3/nyRifrjt8f7am+pHxNuMkzp3/lOLcPULn/qWH9kOXI5yq2vl3GKFbd7HpGheFmQi3Xq98LyiyBv3xEIscsSrd+ZgbP4eDKsIEL1Cv3tyKQ4htoUoF1tlXNgzxrpEXYZIDvDiv8iY11Ua1p1vfIEnLS5uH6/eht++8CmG3T/bna8j46fm881EvI5sb3DG77vfSvkce8lC5zne6tAlFdvwwEz7x8fPs2PdtkoMu38OHpv7nWc6J7xhulvDddY5odk7pK7IbOGl2fODhnnjF0f9N/8Wb1/3w7ZKHD1pFvec08e7qqZWSutmMJ7bFIep0e8Dndz6L6iwTzuBm817HJOXnPYalDCUuwXfqZiZ1aR3lIut8lKzF2kpPFs67+XvrKxG51umJSdUeB2h8y3TMMfDrcvKjJU/Yd02tyeGrH7CS1UbjyfrZTZ+65yC1zZ6PDOOs5Cxjy/Eo3PsqzbjPrZ9MxbQx6u3KfVxd1wX9yjMbcbi5+V0m0vFfvH6UHHMRmkKhelf/OR5XuSNsb/aIewP1EqZDW58ZQU++n4rJr5lX2TkN0FubuITVAh+89Nuz/NBcnXu3+CeoA3+bqQ+nB75766qwWVTjDAOMjvIqcpuLewVEXUO3so4XlpzR6NH5xgaqujVz1zp3aH9kG2zvNuxfrj43jjy6w2YR1qrBuvXycy2T6RmV3WW/c2m3bbhNs8UITLjiOzbb0is9vU7ZiWqPrn3gD12UFV1XMrE8sE3m7krmmXNXUG15X/M+Q5bnZq4hSBymbdxjJXdVTVStn1+fVKZiSbhZatcRISa2rh4ojcAUU7o5qWwFzWw7ZyFUV5xv83nLsovHQ2DMYavfbQir3Ksw3PRYjGvELG2ukA8yrDHxmFYxollk0yb+N/QeOSfjbM+5z6+0Cbg3vtyk7RHhjPIncyG55v37EfnW6bZvGh8zTgRdUqne2ZVTa20wOR9FPxcL03Sact7PDY7CWJdL+Z4n4VFmHN0B2rj6HL7dI8U6mVpzV4RkSb011lutzFu2sQhv+euqg1ZV82t3LgLUz9e65HaXR8r1k7Mq4aXN45TUV7w7Wape9lRWY2/zfa3x6s2WD+XWOOn+wNlXGs/HsT757tECIh/W9zysrkLl5Wq6lrpe+KZhmRvIx33xrC3p3Rp9upZCLHWVXaCNsjCQF4+MvtW59UEbSZQ6aheaQmEed9sFvo5qwqEvn9MRX3cuMN/NaVXOVYBULFlL2Y4bMRefvbO/Gau3CTVuf0W95idNKZsxuGMTCz3VxTjCaPE//LFJBlyWEtBXt6mMSffbNqN619eFqAG8lRVx6XbWTqLdngeWtLXeiQO8tF0CvswV7oGqc/tju0MVbDeiUwfi1Kzz8+olyo70HDSWo9c9Oxi1/lkujTaoEr75ZVTXRtPHn/YsaoRMCJSTnqHH6yL1+hE92LVRvy8cZC02as1WO7HzGFbFXnj+El7XlU6tWiAj75Pufdxn4d3ttiy+wAmPL8EFVsrfVKmhzXgXZQ4R7gqQnH15r04tFVD7rkgdXdO0IaJ7b4ExTir/NLidYHLs7Y/mUehbfaKqAhS0epTQMaMk04vVBt9OIvyc6l7aTF/KTjA92QR2VZbNCz1vI5HEZGiNw7nmFWzJ3LVz/wryDtwDqe5Ofjku7hiW+SCHgD2VNVg3rfRL7N3jZwUrv3180vwOidSpFRMHw68ldhh8eF3EouqQvq6OnORyTbKaJh5KuzlXxZviJjaLNuvHGDTrir5WDiOa2XhJfVbpcsLnmbCm6cQZRdnQFlJTHidPQ/jfIxjdvHCbx1BESfqp2yH5L1C5yK15CDBkqWMUMgE1728DP/6sCLyckTbGvLg9YvPLLtMmVz70qeBNHsZ23Yo5Ma0jI0obz0vzThqGwmLTRp+DXXb3v0Y9Of3ccmQzgq1E5crgisMa5mnwF/l4emjYraIxxmKYzEAcfx9tndcFHNpvroZx33M+g5jMfFIwfcpcuoiEibWvGak6VYbFnsDaseq8NxxRTQsLXZ54Ez5qMKVbtGabZHEsw+LXJmEt6K9cRRJd3Lpv5+ul8pn217Du2bO13KLq+zlppe2Js4CT1ypxAiKM5bUNvyehznCiREpenN416eIY7NPp5+KzDhhDd9zCVlN0W/FspX6peKdtuyZBHtPQb1flMuJuBjG5Fx/rURpwspLYZ+OGWdXVTX+l1ic4qeVmI0yyOtR3XLOWZfq2njgreS85imc1MYZij12VrIyc6WxMUsRGYtt5OvDmaC1afbiVZQy4X+dOIV9poRLNpC9NXfYa/GF9UvkhH3QGDaZehsiORF0riEMSiX7WhDy04yjJEhTv1/5ZB2aNihRLifIpIra6MN97LqXl6Nd0zLlcgGBB5KHZq9qQ2UA5n+7RT49b4LWodk7JYDs8+PV3OntwTNBFBpOpcfrI8ELuc1DJqAd/7rMiHtRMV67W6miKhpkn20Q8lLYqzQwayO/+b/2+NR+2aSj2as06C179uOJD9weGbzAbjI4l+QDYm2qNs5QoijseWEpvPh+8x7scmzTZs2CiDDbYSpLRxw4P14bEmse8le/94cXWlmE7IgycHTKDL2I4PvuyhHk7r0cK9JFStgT0WgABwDEYbwKQsIExBibE1ntAqJmDxcn9ssm2egDNA6vfS6drNy4i3t8d5V4mboXvJXEoudQy9TtiKofofOfWuQu17aClmFHpf1j8B/BLkNOeB23SBQTpYClPS8YnYhqyffLgtrssyzsl/2wI5T8DZu9Gl6b0aeLbM7/BDAKwL8AnJz49wyAIRHVKy1UJi7TaVeiTa9luPW14KvyTA4EcPkUIeqUhjeO2h3K7Kzkh7Uj8ur2ScX2wHkXCYbKUciYFxf94IrPnikal8kP3F3P2ONhyLa7WsbwL8nd3exFZ0baRylYg5I1zZ6ITgJQA2ArgBkARib+JwBDGGOTIqtZGijZ/LyS+mRjDv+jXAiRKYSafVzdZl9Vnf5HyL55ebidvySWmU7OGEtuiXd05+YZKdNK0/ol0qM/bthrAbKj0jhjeGGR3AjMfp3yJYFo06QMP2yLbmFckNuI8gPk9+kfDaAWQMvE7xYwtHoCUC+yWqWJZKA/AOFoEXVf1IvZX1Mr72qXIAxvBuvozAw5HQTeu2nZqJRzNHys8jOdkUhQmpSVAJCLwcTb0EaE7MjZ7xvduKyY+zHKlAtsmDF3RKgqgvUi1Ow9c2aM3cQYuwXAbgBLE/8vSfyrT0RnR1azNJDdAxbwbpCyH4I8UOyFmn3lgVo0KFGbx6+qCdeM86dp/Bg/QenYvAH/hKSQkR3phGlmC0KT+vLvzR0IzWOC1idUhyxBtwUMi6iFfZCPVpRxgXw/I0Q0AMCrALoCmAZgEIDhAF4EcHhkNQvI5t37lTaMDuN1qy6cyEVE7XJfdS0a1FPT7KtC1uzDRuSyKluirLAPOoEeFo3qKQh7hQlaFWXKC9HEf6Zs9qap8JUrj8GpfdplpMxsIjNmuBXA3wAsB9ATwLcAGgP4EMDCyGoWkPOf+hivLFkvnT4VGoHney6XRz5o9iLhWnmgFg1L1TT7MCZo73n7S/9EEvDuqplgLYXs+5Z1Rd1dVe2fKEIaKLy36lqGvZYQCF4CN6zvsOgphvQt8cX8wHVt3QiHCKJ2hpG/ClF+5oStgYhKACwA0BBAXwDDALQH0BnAUABrAJQCcO+knUVWb9mrlN5s1Lwht+yDz+cJ2s2796NMcsWkSRjCXuRuqgpPMBULJmhlNUpjRbH/Pe7KsmbfUEGzn/XVJvS6a2by70yYUkRxYDLlAZsM7xGR6UT1GTauVxzp5LRQs2eMVQM4HsAGAGMBtAXwJWPsDgA7GGMTGWO3yRZERGVE9DYRrSCiqRSRhFS1k5kP9843vgicV90X9d4LZeqXxpSi8amsIYga3jsUtbzqGklhL/kwsrnsHgAaKk6sW8mEsBe9h8/X74i+cKRGs1GZyRlTG/U3b1ga6eS056efMVZFRM8xxl4kos4wBD5gmHVU+RWA9YyxU4nobRhunO/6XKOM8qNKPNz/cTZrltfsVQvNPbziw5QVFyFGJD0szaXFSSp1kZ1YlrXZhzFRnQ4qmr2TzIQs4D9Hma0vw8BUcKIKqRxnTGk+L+rIzr42e8bYi4mfJwJYmTj2XICyTgTwXuL3bBiTvKGj2kbN5LwXLhvwKR+EvZdmX1ZSFGnoVT/aNAnu5csTWkTA29cOxSPj+9mON60vFxdJVrPfwtkTNpM0VJxYt3IHZ6QbNr47n0WM2TaiatvvfrkJzyosKuPt2xAmKk6dzQFMI6IXiGh0ADNMSwDmDge7YPjsR4ZsQCHz4fKEvWwjyKYgDAsv75eyklhWP2jpuPrxbitGhCM6NEWPtk1sx3kbcPCQjQJ60/995p8oQlQmaJ3MDjEYmIjtldFNYHdoVt83jangRNW23/tyk1L6opj86DkI0sKeMfYQY+w4AE8AeBzAWiK6VqGsLQCaJn43TfydhIgmENESIlqyeXP627CJJuGcmDYynrBfv11udV3dF/X+mn022br3QOBruTb7xP8yMvuIDk1cx6L0hQ4TFdfLbHDRMQdHlvedp/b0TZNU9HJEWYtx9m0INX/ZhER0BRHNBHAzgNth+NhfrFDW+zDi6wCGSWeO9SRj7EnG2ADG2IDy8nKFbPnI2uHMZ8vrwNJ7jOZIY0kHb82+KKcmXVXg7dhlDkplRmRvXzsMQw5raTtWHGEY2jBJx2afCWTNZkFQ6ZK5MjIvirn3Wg4TldbQDMAljLHkiiUiOlfh+hcAnE1EnwFYAUP4R4bs62MMqDxQgy17gmuPudFU0sNL2GdsT9AMkdLsU/fVpKxY2lUyV4SDH7JzTvmIyhuKcncoFXLGZs8YexApbxwQURMAHRSu388YO5Ux1ocxdiGLOgCG5PtjAL5KI/ZKmHRs7m9njAovYZ8bXSE8TFltFdpepipnS60rmn2+faSjIJceUc6YcRLcCwBEdDSAEgB/Dr1GISGrfS2p2IZz/pneQuCwFL312+WCVkWBp7DPUIfIlCaaNONYerpKHBvZ+aBsU1c+SlEg6z9ifhBz4UlFbcbxbLWJCdOPiOhjIpoAYD8RFQG4EynPmpxE9os9/YufuMd7tXdPzInLShXmF486Vy0AXhO0mYr9k4kohFasE3NeG3I4O2CUW8eFSa5r9lFqsbJ3nvwo5EDHLMqyZr8bQBWAXwJoBwCMsVoYa8XjAKILBp0m6S7QbaCw+tBakl+I0ihDmKaDp89zhvpBWAG2ZLEq6Cqafa4LUZNMxe3PRXjd/6JjDna5ZOaKJw4AlBRTpKEiZFuDWYd6RHQRgE4ArgKwLpJahUC6r1DlY2FN6i/sc3PSzEvWHVbeKPTyeJEnvRT71o3D3z7Bptkr+PLXFTNOXfkoRQGv+47u1RaTz+5tO5ZLj8iw2eeAn72FGgAPAxiACMIdhEW6mr1KI7CaOfx2moly27F0EGn2gw9tgaMODn+XpTP6Sc/tA4hmB5+gwjBqIfrns3r7J5KgoG32HHUvRuT6COSaZ1VWAqEJ2A/g/wC8DKA+gNdDr1FIpNsflTq0JamfMPfT/F+/Ojvb+tYKNIqDW4Qf+hUwFjQd26Wlf8Jk+vQ75Y0ju2HCcYcm//ZzuTO9o5yPJmphH5ZXVlTVrFccQ6vEbl//vnxQ4HwijVvPufcYuYV7rrhdAoaCmk0zTiMYQv0VAKZ//QgYMXLiAPi7QOQA6X6wVb74MSUzjvf5xmXRLTTxQjQ5aj6Gs49U08T9KCLCQ+f2k06fjpZqCuejD2mB236R2m/Hz15788k9ALjj6+SQfPAkqtDbpUUxzPnDCVhyx0kY2rUVurdpHCifdCwWlx17CAYfKo64wrvzophb38+ld0lApLPWftsSHs0YO4YxNpgx9iSA+oyx6TA2MXkbwDtElJN2iXQ9SFSEvbUsf83e22afrcbnF3/m1xaNOAyKYjGUlcg3nXQmG0sFJiC/d1ya+MA4N1CPev8CZ/afTRyF4d3VV5VHVksylJJWjYx5lGxYQk7oXo72TcUjIN47IiLXQ8mleY0YZWnzEhMi6gBgD2NsJ4xJWQCIMcZeIqKdjLGcXEef7jtUsuJY0vrZlv001GxthOLn9hi2bbMophZzJ51OWVxEQLVbafL7fpgTsc7NWIJUpXG9YuzeL7dC16moNCkrCfT8o7JHO/PNRpstipGyCaYoRjlRdxGkEEY8CDLq0qkwdqoCY+x7IqoP4H0iOgHA04m/cw7rS/zbeUcqXz/4UHl7srW9iLRIk4fO7eudl3Sp4SKy2adWm9qPP3XRgLTKi8VIyQ01HTOO+QF22oitZpwrj3ePXEoS9atyCfsAgldCMD0yvh/+dt6RXE05iEyKSo65JzmjKcevDl7l8vZniLkV+9BcL8OI87O7qhpfbNjlubdEOsj0thoATyV2lzoZiQlaxthcGAurclKzt77D9oINpr04vF0TnHR4G7myLE2onoe22qFZfXRt0xjd2ohdGVUFSVh++16LqgC3BjSyp9yzEVEcIyWtyu8j6kVyVOAx0XrxMZ1dC+lKkmac9IW9zMikd4emOL1ve+W8RUS1GM5t9w5WTjoirYjcWroVXns2vHEcE7QhPaIwvhmfVGwHACz4botPymD4raA9BUA3AJcD+BOAKQDawAhzDAD7GGPZ3aFBgPXhBzEB8Ny0ZMqSEUqPXdBfKi8Zwgo/fEC4gtSoUNjam9lRZT/E6ZhxzA3Cnd3f2vGJ46lhjghc2wsGqEr6tmH162Xa0ul926Nlw1LFfJ2mEKXLQyHmY8ap4SwciRG52nFY3jgXDg4vXPPOfdHE+RdKpsTmJMfDWCXLYOxD+x8A/wbwUCJZ9oK5+GDtuEEWwfCGfDJ4adqpldninFU7TlhCuPIA355s1scqrJ688Ki0yzPz++t4ORNbejZ745142UMJbkGQFPZhaPYK1/CqmUtmHOdzyobd2ym4nVWo5mj2RbHo/OzPH9QJ/3fVMaHkde1Ly0LJx4nXhuOMMXYLjA3HuwAYCuAGxthfAfQgomNRR4R9IEHB0fREWDU/r7gpZsx8r3xVG581/R9P76V0rZVNu7wHaNZyRvVq65FSDtMryflqRN5MaQl7U7P3sBsQuYWW+S7vOfMI23FRVbxenUz9zfJ5/udB7l6mLQWTdXKmkNNCNEk5KYqR5weUr9m733FoZhyoTxiLiMpDSEbl3QJgOYAxFs+be2Bo/W9GUqsQsD6uIJN7KmacJWu3J397uVaagszrXap2Pmv6dKJGfvfzHulyvODt7MRj7FEduflad1fq0Tblvy3bAd753TDXMfP9e9mICe73Ymr2FwyyD9FFQtQreJ5ocGldWGbmyps+iUqzpwB5O9OLLo9yRy+n4HaWVFPL8LTDiSDG87MPKeolUXiTvVHFz/Kz2RcDOBbATwD+RkSziOhdAH8E8GsA/4ikVmGQQZu9FS8/+5Sw9zDjKDY7m6YSQd8ys5QdcZzQrbVvmoNa1Lc8J3u+1gB0KgugTHpyBK5pxvOMO+Jhs+ckFRz3GtX5+/qbP/lbKQZrw1HgEpiCcvyCy6XjZRhzTNA6NfbqeBxNG5S4rnFr9uE8I0J4GnlUwdn8PiHXA/iZMbYJQC/G2EmMsVGMsZEA/po4n5PYbfbBJreC2CI9hX1CeHhl26jMf/Mwq/um9dai6Nwp10u5vGWGstZO7sy2oWWTbKuwTefWSqQ0e7d3h9AkF8CMI3osUcZmkck5SBt3afaCLPY75jrCJEZk20OYp9k7n3kRZ4LWT7DeOLKbXIUoxDmSqOZavE4yxh5kjD2Q+PNex+m/A1gfSa1CwPpSg2n2qWd+Tv+O3DTPXzbQdaykKCYMj2x+CKwd7MhOzWxpGtUrTsYdEXHyESmbuVXji05syNs2VbUSp7D7elNqz9jS4tQ5laiUrjoJXC+tEKezijR7kYD2unNeG3zlymNsoxfzXfKqGUiQSJpxVJFdmOSc2BZx7lEdleMBORdIuSZoa+NwzS3E3CMkv+cqa4fnKQsqjBvAlzFhorIt4UzH33HG2CvhVykcrC81iDcOWYaJooBNx3UrTy4ZNyktNuKGPMHxWDGFh5823qaJtzuiqE2Zx0el6QNvy9N0vZRs9Kru8LxcO7VoAMD+3qoV4s07KRYsqnLWwymQxcJelIl6Z+/etnFS0CUvD8Fm37Ndk4ytoBU9j2O7tPLMx3wfh5Q3xDXDuyjVoShmb5NOIV5dy1wjM55p1k8RVHG/Tud5n3JEu8DXypKTcW3CwPrcg4RVIci9aGeaesUxtGlShv6dmrvS1uPY7HlF+NkyrddbBZh5uD5nZHH/OX0CB6xylulFkeLD5mVrhm6wCtt0hL052vD2xpE344js56pdPWWjtx+XjQbJW/VrMumsIzK2Glv0PA5q3gA3je4OABjYmRO0jKWuVx23kdMk46jCWUd2cI2wi4vkXS/PG9hJeN65AYpZfFomewIOadUwmVcU5LGwTz2yoHFFpGyejr/rFYvt8kkzjqMcJ34NX6jZQyzUxh19EC49trPr+Nw/nIALBnXyKVHBjJNoUcdIhpvgPWVzgtIqbA+kYcY5uKUxUmhYTzwfwvu4CydohfZ3cR149ylKzvWz56Qe3l08GV4ciym0e7X+4cxW9HEiAq487lA8/qv+GHf0QbZzVo2aSH2ytojsrpfOO2jbtAz1S+3vuzgWcz1H3juLEdAw8aHgPZl3fjfMZWqlgA4dyesB/Mnh4hs2GRP2RFRCRG9lqrx0Jy55M/c8RAKCF0WyNGlO4F/fu0NT3/JmXD/M1mB5k52ixUO8o80blHoGbzPzlJ3IM5+110Sz1wQtkKqnVSDw/KZlOLxdE0w8vRf++st+GHSIOCQu4G4n1tXJ828envwtehZez8hLWz8rET66WcJ7hPv6FJuwcwFRj7aNcXRn92gziBrpvM2PV2/jpwOhuCiGk49o5zLvOYWsamz7Ike4Dd6jb1Di1uydA0+eefLhcf08823aoAQHt7Tv82AoC8GlfbofCxkyIuwTwdKWAhiZifKMMlO/A62pIr4N9UpHqF+npmBq703qG8LOquGa50RazIMJLxsvF8EebZv4enaILj+8ndstsZa5bZtWzDMyz3DsUR2TAlpap+QkND9W1s4zqqf6Qq4RPVrjgbF9UFZShDOP7OC7ctnrHg9KzCOI6gwE0OwTh34/shu+uvvk5F4GsrLe6xkXF5GtzBnXH4dXr3JvjBPEpTMMN1Dnu1DV7J02cl6dnObMEq5mb//7uhFdcaZl7wbZe3W6gqpCnLqETUaEPWNsH2OsDzLovUOglMsdU1+oQMR/0bdavCcAdwc3y2lQWoyKe8fg8qGHJM8lhb2lO1vbuCnk/Bq+taPwRglOLenXw4w69DuoGd747bHJ43ee2hMtGpYmJzC98JvIOqNfezwwtk8ynZenhBXeMzaV+AalRbj4mIMx9fKBth2mZHnmkqNxhMRoyayHtHupIJlXnCJ+1olnFSObYJLdh9RrsWCMCDI7Tfh5fvHzlktnvWe/lauqRrqiGLlGCwtvPdH2t7PP82z2ofm0+ygLvpdT9LH1IxH2RPQYES2w/PtzFOV4ESPgucsGYnj3cjSpX6Is7GUXVTkbsdMDwTpsLC0yOrStL1t+m8f9hrTC5foCm/2YPqll69agV+aHyDTjdG7ZAE7M+/MThKbZy0xnvW+vDsU14yRuIEaEP55xBIZ1LY8+2Bb5D8NP6F6Odk3LhM9iaJdWwqBiKvFu+K6X7sRHHtQc143oys2jmLNalMcNsn7kPnXxwxWAjByTsoqqvdPMSgS0c2xm4qxnccztZx+0XTk/yCLlUBZekLawiUTYM8auZowNtfy7ze8aIppAREuIaMnmzZvTrwQRhhzWCv+6dCCKYuQZelhwefLVqTRDp9ukVTCUJPzGRa6VshsXiG3Gxv/ObKypeTZKMypk/dJi4ZJ/2U6RNONITpDzTp07wJjMs4ZOiFrYO804vIV4Uy4diIW3jhCvoCXg4iGduedUbNL8CVqDR8b3Sx6LxUgorHkbdfAIEjVV2kRn+e2sS+vG9WzpVEO4G4uqrGYcifoQuVIG1aZdEVSRXhs1rq+Dmn0QGGNPMsYGMMYGlJerb8HmxPnYShRfqtUG5zWs9ns/1sZUL6FBF8Uo2dh5QoBXXL+DmuHta4d6lpX6OLm1DmcaK0k/dMaEAkLa9ZLcNnuvS3n53jy6O1bdc7LNtBFVbPZU/vZ35f2BUq8LN96NMLW4vckqwDyThQjl2wnwKo7rlurTHZrVx4u/Hmw7L2u6MilyaOnW92WNN7Rm8i9s1/m5XsrWwumAQZR+ILSobfb+a/PrKOmGYSWkTBGey+z9hL0lgTWUwtMXD8C/PqywxZFPfQDcjOrVhmt/tnu28M04VkHJa1DWuY10l/Ura/a8smKEsphd41R5fU9ceBRWbtgpfwHg8rP3nGfwMKOJLuON2lTapGg+RoTf5h62vKVroZbeKvwa1SvGdSO64pH3v8XYozqivcNXXdVmHyPHYslEUW7hbq+ta0FYsr3a8/erj3PdByF9P3vz+qg0/Ixq9owxtWVyaZDuV9IIouSfh5/GaW3wVmHfp2Mz/OWX/ZKN7J4zj0Brj5WzYru3e1GVU4v080yybtsn2phC3s+eXOmd1x5annJbk9Y+5ZIBAEb3aovfj+qucIV7GK46GvG7TkVx9TLjyOYT5WSf1/2fbfFkGdHDvg7AWXWrNq/qjROLEVo3sZuCANOFUV65UHlMy+4ciU9uPwmAO8ib0ztIlXTDLciQM2acsHE+N9XnWN6oXqAVtE6sNlHeLlZmw2xi8UvnDWllOm+qsXhHd3SSFPYemr2qtmFtuM5G/NC4vpa/5PKNuiM4O6vXR1x0xquKXM1ekFZ2gtaL4lgssnmO3h3FHk7mfEu7pmVSXl6A8dzUNXtCO8suZ6rrQER/e9G8YSnKE6Nvt2afnqGRKPp5qfwV9o5Hr/ogiQhXDD0EnVo0wClH2H28x/RuhysSnix+2Vonoko9Yt1bUWn4NjNO4n9vzd5dY9OFL86x2as24ZSPvKVMyxekZcNStG6c6qRB3PiiwLlTVZA9B0qKYkKhwzfj8PPx+jBIa/ZF3ppiq0al6HtQM7nMLIwb0BF/Pqu38Lz53GQ+btYkPAVn/NEHCb2biojQsqFFsw/Yjsw/Ryc25BndSy6uVHUNxxsnjUaarp++DHlrs/d7bkvuOAkD/jTLM82h5Y0w7+bhWFJhXyH4qGUPWb8XXG4T9pLfVk6HVtl1yOUWpmSzN36f0L0cc7+W94oyyzQ/NHbN3l3H1N+SduVMa/Ye5XnFU9l3oBbLftiBWV9tsp2LOxYAXzCoE3q152vIXitoZRWBIvL+TC+5I9j6xiM7Nff04DE/7CpmGVFNnatkbdcQUGLpT0Fbx/urfgZgLDisuHeM9HU1zheK9P3szXYVVVPPW83eT0Nt0SClMfz78kGeeZlZcc0wPvWwhiI4+Qi5VaC8fiJqSPxFVXb8vHGSdbQMJYPuMpTU7C3H7CYo53ux88IV3u8iSvyW36dOug+d0a89SotjaNqgBE9fPMB13vkBnnRW70B2dVmvFVnXS0BNuHglHdqlVbJMVVdKWbdjkxiRsocdwHc9DsL+GjWbvd8oipDq4+ls6uJF3gp7P5u99e+hXb1DsZpNnBdNUkalqLh3DCruHWPzG3de7jekLfKxf57dPxUOwOWN42fGiaWicZrnzciT1uSje7XBPy2jGi5czd7D/u041cyxu1CmILKHZ/Z6rUGG2yrCj6/Yq9rso4m14pXnkxcdZRFYHu6jjv+N9Mb/vD7CozhGtjmBWskHHNYj4drsPTL/zfGHeeZHFN6HSEThCHvXefkHayblBQxL9/XwqsFrtn6a9h9GdbfY7MVmHN4SenOTEELK3dR0I7aW+sSFA3BKb++421ybvYfGnM6EWZg4vSG8Oh7vjCj19Sd1RacWDfDbE+Ud0Zp7fPBkvxkxDxOIk4NbNPRPBCME70mHi23aDUqLU2tTOOdF1bFO0J43MBUdk5dHUYxQce8YxGJkCxfh1LRFqLYvUXLnZjp+Nnt/Oa69cQIju5uODOaVPOU6LFuyn/+0XwwPr8bmZ8YxNXsioHE9Q9CkfH49i3VhKljWuqisdMySrHc9P1XNXvTsrz+pG+bdPBwXDj5Y2iY8tEsr1whKxtEqKE9ceBQePd9nxAZgzh9OQEvHZj1OzHetapZhnBEhD+tZqwLkJezf+O2xSVNtWO3LOZKwmmEAt/ec731R8D4nS94K+6BCeMhhLXHfOXZvAzMv3o5X6Y68eJfz+onIvmuNI8MzCTnL8PLGIRD+fHZv/H5kNwyWjEfvqg/cmr3oN+9vFe3GuZXdHWMOF6T0h2C8+1S95E1PYUNErvkdryJ5u6Kp0LxhqbQXih/ms4lzzCpe8j+p7Ahu9NQ+7RLpUsjuQNfvoGZJU21Yr26gI1y205vGGUnWa37mvIGd0KdDU63ZB8VltpG87sVfD8Yvj7Zv5pHS7DkaXQTL+HlavleEQ6MesAyhxeESeA3KuhF6i4al+N2IrkmtSXXnqZQ3TuqYXbP3HnH5fTzbW3yrLz6ms+3cFcPUI2Na63Fa3/Z45cpjfOsRtWcQr4zU5Lu7bZhug4D9+aRTnpW+BzVzrUwV4WXGSZaV+N8+T2We49fD3PHKildo7qh57tKBtj2onRO0TpOvV5OZfHZvFBdFty7CpHBcL9N4kF4eKlG8ICXNPlkPsmhVzlRimzkA7uKXXw0+GOu2VeK3w70nltwVSo00TLw0FpWwFi9eMQhd2jTCwEnvAzA+TGFhltoyGfJXzf4atdjx2oXMyr3n9LHFoZHF8yPL3CurRZjt1FuLF+PrWGE7F+Cph/Si6pcW2Z6zc/MRp+ee2QcalxVjd1UNN0+t2QfE7XoZHLOjRbkEnaflWBFN0DKLJi3S/rzMKNa8rZ2nrKQIfzzjiOSGGrLw/Ow9zTiON+PV4Id0aWVbkNUiQCx2EWaxyRDNXpo9rzVlSMn0s4QHdZn13mVLHs9FVR5VYxyXXdu1mXrAaWC9P6dmb7arQ1uJJ8OTfvbhV83IP6J8s4LV3SsKucw141jecL8AKxKDLvMGjJ2hrPmYHcK1gtYnH146Vcwif9G7HTq3bIBLLKF+/3TmETisnL+Zsp/XlBdeHUcVcgj5IPFvoiT5IfeRvFEoJH5lPnRu36QXjcj9F0j5mvc7yL2Y7KSexpzBLxzeXknzDtn/d9KmiffEsYnZR8z9LWS2ApXF2macZlfTGur1fupkPPtsYZ8h97YNq2Bqyjy7uXUi6iVH2NagjOzpnixzll1x7xg8eG5fywSt2GPDz8skOToIoTWUN66HuTcNR2eLIG7bpAz3j+3jqguvPipD2YNbNsR7NxwXuK48ZDT7IGEG0sXLZm/Fb24nCH6eNecc1RGTzzber+k1xrtmePfWWHTbCJzYw92+e7Q1VrDK7izm5J3fDZNKZz7HRvWK8emdI/HqVccEKo+Hte06zTjmR8YrXlDBxLMPgxqL4E1HY3RifkR4k5XVFgM5d9GVJNa+cceYw122cr+JUgKhScLkYt0v1TiXgidMkx40EQ0gVWLDq7b3rm0aB6mSL14d7/hu5bj9F8E8f646/jD0aKteZ3OD6zaNvSdgZT1UvLhmeBeM6NE6uX+yyoIwv32QrRv3pDy3xCZKP7OfiZ9LqCtvGHM+QTZvEWGtmdOMY378nC7U1h30otbs82qC1irsw9p+DEgJe549VHblngieMl5cFLMFeRKV7aRn+yZ46qIBOLZLS/z309R2v342e7OjDOkSzN3SD0MA8Ovvcr2MusWHRFuH14vsh/KWU3rgllN6KJf362GHome7Jhjms9o7DDPOHxKeL4vXbMPCJxYqbSwiOwIBrB44whSufJvUT09kyT6dICELrG3ZOcIyZZP1+OtXD7FtpRi1Zp9Xwr621irsneaC4A+yJqnZu/Mwd6y5VmGFpKNiXJzDYNlOzDMB2VbQchpUh2b1Me+m4ejg8FsPC7KYmPxGXNmW9bImLT+vkbApipGUl42MGecsS8x5vzIBtQVSqWukL/HknP4d8fgH36NFw1Lcc0YvDOua/i52UWHtW07NviYRXsGqtB3ZqXlmKpYgr4S9NRJdmJ0vacbhZGrGyHDuvCPLYeWNALgnmI45zK5lC71xJMqQeRadOJuNh4X3oqrwPsphkArk5l2PbIV18MNvBKgS2TGI4JbZylOFm0d3x+9GdEGD0mJc6FhXEQQKuX4inDb7Gg9TsEnUdcorm73VpJJuPHsrvCGY8xwvbo4MVx1/GF68YpBLY+nVvikq7h2D8UcbXg7NGvi4GTqq9vrVQwLVJwrIsrrX9V4cabOu2Sf+96tHUBfHqKifsD2rLoLzwrxHFSGUcr0Mpw6xGKFBqVgn7d+pGc4f1El43onAh8EX52ptP5yywssU7CQqc05eafZN6pfgzH7t8cbyjULh/vC4vurhVz3MOKZmH3Q1X1GMMKSL2A478fReOPPIDujSuhE/geBejuzUHI3qFWPP/hrXs7hxZLdAC2+CYngK8Z9PGDGMnr1kQOCRlZNUIDfvekjvTZAhurdtjOXrdmB/TW1oeSYXSClcE2TOJR3Z9trVxyqlb1DP+ChaXYP9WHHXKG54cy9cZhxThnjIiUaJ3equGR7N7q15JezLSoowvEdrvLF8o1CIdGvTWNm9q8bjq2yuhmtaP5rQvGUlRZ5xas45qiOmfFSBshJ5l65rR3QNrX4y2OcMXCdtyMiKxy7ob9sUhufKF5SDmjdAz3ZNfOPsOIW9s9ov/XowqqrTE7wn92qLU/t6Rxk1eeLCo/DcRxXo1jo876SUZi9/Ta6at0zqFRcpmbIA77799/OOxBvLNriOO4V940To5g7N6uOJC4/ixg4KUjcV8krYA+5FGCbpNMEGCZdK68y5kzCX7qtw56k98YfR3VHPY8vDbHe/GMFixvFGRrN3LrwJk9LiGN65zt9nu55T2Duq7ZxzCcLjCgHO2jQpw80nq3v5eBFkgjbHrFuRc1rf9jitb3vXcedI/4Tu5fjLL/viF73befbVKMmIsCejB08B0B3AzwDOZozxA0SkScpnXI1HxvcT+twOOawlHh7X11PIZEvYF8VIuOFDUsBmoAN6ygObN47fxGd4dYqS0qKixP8xHKiN45QjovsAZYtAwr6uvEAfZFxHvXAHQiOcdWRHQerMkCnN/lgAxYyxwUQ0F8AoAO9EUZDpkOM24xj/i9rtGf3E7mhEhLP7819Ui4al2Lb3gMsvPpfItoeLLU6OT9pMRJQMA9OM06llA8z6/fFZrk00JLcYlNsXxHaNDH4TvxE7p0RKUIeNKMmUsN8E4JHE7wNRFnR0ZyPOtDVuDKC22EOFf17QHzVxltbq2ajJtvyMWeL2OHEtqqobsj45TK+pVZCEdYwg7Ubl/Y096iA8t3AtTuzRWr2gHKe0mDCqZxsc3LIBfpfhOTIRkQh7InoMQB/LoXmMsduI6CwApQBmRlEuYGhavEkO2RCxqgwKuMlHJsm2/CRYBIdPZXJ9gs/E1Oyd29PlIv07NQt0nTnKUrPZy7+/3h2bRjohmU2KYzE8eZF74/lsEomwZ4xd7TxGRKcDuA7AaYwxl5sCEU0AMAEAOnWS95uV5ZHx/fD4B9+jV/smyWMPndsXrRrnrvklbXJEbqqZcaKtS1iYw3TnxtO5xpd3j5Y2KTxx4VE2F9+Yj+mTR135WEdNwZpxiKgtgJsAnMwY28tLwxh7EsCTADBgwIDQ1aVDyxvh/rF9bcfOOSq7EyYZI9v9z6P8RqXFGHRICyxasw1A3REWZmeuCWv1UER4LUhyYt3xCrDY7LU3jjIlxbn3IDL1+bkYQDsAM4loARFdlqFyCxrRqtVMYw2/7NqGMEb4z5WpMLN1RNYnbfbVHhtd13VaNaqHYV1b4ZHxR0pfU1c+1lFTEuJK5rDIiGbPGLsPwH2ZKEvjJtv9zy+evpW6Iiwalhbj6M7N8ZsTFLdtrEMUxQhTLx+kdE2+uF6aBPUOi2JfgXTJu0VVGjfZbnbGoiqjFn59p64I+1iM8OpVuRN/SJNb5KLNPvdqpAmdbPuu28Il+Hx66oao12SCuuxnP+Dg5tmuggut2RcAmRCgngtobTZ773zqiGKv0XCZfHZvtGpULyddsrVmn8eYGn22BSiRv5Y2+ezeaN24XtZHIRpNOpw3sBN3A6FcQGv2msgpIvJduXzewE44b2D46ys02WFEHq6KretoYa+JHOs+AFpzz38+nzgq1I28NeGghb0mcohIYnNpTb7QuCyavR006aFt9pqMohV7jR+je+Wmzbuuo4V9AZAJF7aDfPborMtudJrMMry7Ye8PO0KtCvnYXrUZJ4/JlBb99EUDcHx37z1tk5vKaM1e44M5xxPm5ukaLew1IXCShKtZymavpb3GmzP6dcCXP+7C9SO6ZbsqeYX+dOYxZyZ238qljVW0Zp8+Y3q3w/8X8n6zuURpcQx3ndYLTRvoid4w0Zp9HnPnqT1x46huOeEGl4cm0Kzx6AX9s10FTR1Ea/Z5TFGMcsYNztxvVCv2Gk120MJek1m0HUejyQpa2GsygmnG0aJeU5fIp/aqhb0mIyS9cfKp92g0dQg9QasJzOtXD8He/a694wVom71Gk020sNcE5shO8hs0pDR7Le41mmygzTiagqY0B7eP02iiQGv2moyQqxO0C289EZUHZE1RGk3dJSPCnoiKAbwEoD2Arxljl2WiXE3ukKsTtC0b1UPubSCn0YRPpsawZwJYwRg7FkA7IuqXoXI1OQLLxzCCmrwn15STdMiUGWcGgHcSGn4zALsyVK4mR0iZcfKo92g0dYhIhD0RPQagj+XQPMbYbUS0CMCPjLHVUZSryV26t2kMALhi2CFZrolGU5hEIuwZY1db/yailkRUD8AQALOJaDhjbI4jzQQAEwCgUye98XS+0bxhKSruHZPtamg0BUumbPY3AjiXMVYLoBKAa1sjxtiTjLEBjLEB5eXeG2FoNBqNRo1MCftHAVxGRAsBbAUwM0PlajQajQYZmqBljG0AcGImytJoNBqNG718UKPRaAoALew1Go2mANDCXqPRaBzk4yJAHRtHExldWjdC0/q5sS2iRlPoaGGviYxZvz8+21XQaDQJtBlHo9FoCgAt7DUajaYA0MJeo9FoCgAt7DUajaYA0MJeo9FoBORTQG4t7DUajaYA0MJeo9FoHHRobgTmLW9cluWahIf2s9doNBoHlw89FIe0aoSTDm+d7aqEhhb2Go1G46AoRhjZs022qxEq2oyj0Wg0BYAW9hqNRlMAaGGv0Wg0BYAW9hqNRlMAaGGv0Wg0BYAW9hqNRlMAaGGv0Wg0BYAW9hqNRlMAUC7utUhEmwGsDXBpKwBbQq5OrqPvuXAoxPvW96zGwYyxct6JnBT2QSGiJYyxAdmuRybR91w4FOJ963sOD23G0Wg0mgJAC3uNRqMpAPJN2D+Z7QpkAX3PhUMh3re+55DIK5u9RqPRaPjkm2av0Wg0Gg55IeyJqIyI3iaiFUQ0lYjyaetILmTwHBF9TERvElHB7E1ARDcQ0axs1yOTENHNRDSfiKYTUWm26xM1RNSQiP5HRB8S0f3Zrk/UEFEJEb2V+B2JPMsLYQ/gVwDWM8b6AmgOYGSW65MJjgVQzBgbDKAJgFFZrk9GIKKDAVyS7XpkEiI6FEAvxtgwANMBdMxylTLBBQA+ZowdC6AXER2e7QpFBRHVB7AUKbkViTzLF2F/IoD3Er9nAxiexbpkik0AHkn8PpDNimSYRwDcmu1KZJgRAJoT0TwAwwCsyXJ9MsF+AA0SWm0Z8riNM8b2Mcb6AFifOBSJPMsXYd8SwM7E710AWmSxLhmBMfYtY2wxEZ0FoBTAzGzXKWqI6HwAKwB8me26ZJhyAJsZY8fB0OqHZrk+meBFAKcA+ArAKsbY91muTyaJRJ7li7DfAqBp4ndTFMjyaiI6HcB1AE5jjNVmuz4Z4FQYWu7LAI4iomuyXJ9MsQvA14nfqwF0yGJdMsWtAB5njPUA0IKIhmS7QhkkEnmWL8L+faRs1icCmJPFumQEImoL4CYAYxhju7Ndn0zAGDufMTYUwHgASxlj/8h2nTLEUgBHJ353gSHw853GAKoSv/cDaJTFumSaSORZvgj7FwB0IKLPAGyD8bDynYsBtAMwk4gWENFl2a6QJhoYYwsBbCGiTwB8zRhbnO06ZYBHAfyGiBYCqI/C6NMmkcgzvahKo9FoCoB80ew1Go1G44EW9hqNRlMAaGGv0Wg0BYAW9pqCh4hC7weFENJAU7fQwl5TcBDRTURUYjk0mYjGcNItIaK5jn+fSuRfBmCB49iDRFQQIS00uUnBBM/SaCzEANxLRAtg7PdZBeAEImoHo09MY4ytA1DDudZz2T4RXQDDLbYREb0OYHLCVbIWQHWI96DRKKFdLzUFSWJRWjsAfQGYS/GfATABwArG2HYiWgxgnOPSVxhjA33y/huA/8II7XAtgHNhBKvbCmMp/G8YY9PDuheNRgat2WsKCiI6GcAtMOLrXAtgMoAPAbwK4BPG2FxL8mfgjrD5rCWv/gD+xBj7BRF9AOAKGKOBRgBGA2gAQ6O/G8AAADMAnIw8DuqlyV20Zq8pSIjofcbYiMQ+AA8D+CWASxlj7xBRFwCPI7Vcv17i//2Wv29hjC0lon8AIADbGGN3EtExAH4DoCeAjQBWAhgDu2Z/KWMs70N6aHILrdlrChUGAIyxGiJaA2ADgGuJaC5j7DsAJxHRL2CEmB0LY++AKYmPQ5wxFk/k8w8Yo4QOifwWAlhIRJMArAXQFW7NXmtYmoyjvXE0BQsRHUtEMwB0BjAQwNswYg2VElERgL8gNUn7OyL6H4A3kApKBgATAdwD4M5EnpckPHbOhxF7viGv6NBvRqPxQZtxNAVFQohfC+AGAE8B+IAxNt9yfjhjbA4RnQfgdBgK0T4AS2CYdghG2NlqGHHlxzLGLk18CO4FsIgxFieiuwHMAjAEhuCvgmEGOgjA5YyxQgrspckBtBlHU2iMhdHuDwPwWwATE9vCNYCxI1IzIro8ce4XMIT0WTBCzk5LpCMAtzHGpiWOgTF2hqOc0sS/EgB3M8b+DwCI6M5I706jEaA1e40GyVW09WBo8pUAihhjPD97jaZOooW9RqPRFAB6glaj0WgKAC3sNRqNpgDQwl6j0WgKAC3sNRqNpgDQwl6j0WgKgP8f0mTZgfTu/N4AAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "plt.rcParams['font.sans-serif']='SimHei' #用来正常显示中文标签\n",
    "plt.rcParams['axes.unicode_minus'] = False #用来正常显示负号\n",
    "\n",
    "x = np.linspace(0.05,10,1000)\n",
    "y = np.random.randn(1000)\n",
    "\n",
    "plt.plot(x,y,label=\"scatter figure\")\n",
    "plt.legend()\n",
    "\n",
    "plt.xlabel(u\"这是x轴\")\n",
    "plt.ylabel(u\"这是y轴\")\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5e0d0ee7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d:\\python\\lib\\site-packages\\matplotlib\\mpl-data\\matplotlibrc\n"
     ]
    }
   ],
   "source": [
    "import matplotlib\n",
    "print(matplotlib.matplotlib_fname()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8c0f90ca",
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name '_rebuild' from 'matplotlib.font_manager' (d:\\python\\lib\\site-packages\\matplotlib\\font_manager.py)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_51836/2123356069.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfont_manager\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0m_rebuild\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m: cannot import name '_rebuild' from 'matplotlib.font_manager' (d:\\python\\lib\\site-packages\\matplotlib\\font_manager.py)"
     ]
    }
   ],
   "source": [
    "from matplotlib.font_manager import _rebuild"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "cbe1718a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil\n",
    "import matplotlib\n",
    "\n",
    "shutil.rmtree(matplotlib.get_cachedir())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "e4a52107",
   "metadata": {},
   "outputs": [
    {
     "ename": "ImportError",
     "evalue": "cannot import name '_rebuild' from 'matplotlib.font_manager' (d:\\python\\lib\\site-packages\\matplotlib\\font_manager.py)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m                               Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_51836/2123356069.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mfrom\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfont_manager\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0m_rebuild\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mImportError\u001b[0m: cannot import name '_rebuild' from 'matplotlib.font_manager' (d:\\python\\lib\\site-packages\\matplotlib\\font_manager.py)"
     ]
    }
   ],
   "source": [
    "from matplotlib.font_manager import _rebuild"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7aa675f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x21230191438>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "1adf0d09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6843547, 1451016, 18143322, 11690064, 3864415, 866921, 754371, 1040867]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "base\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8a724e21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5160445, 1305759, 14762695, 7100441, 3042936, 747585, 646754, 670186]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "4afbd22a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x2123079c390>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXYAAAECCAYAAADq7fyyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYB0lEQVR4nO3dfZRU9Z3n8fdHwbQZFAy2AqLdmijjw2gHOyrirsgMmIzGxFF38SEKjnYyOXkaXXcdXTM4s07imZ3JidE4kkTJONG4jmFW1AwqiA7PNDGgi0OMBrERSQOOT0iM5Lt/3NtSlNBdQN2q7l9/Xufc07du3fr9vvd296du/erWLUUEZmaWjr3qXYCZmVWXg93MLDEOdjOzxDjYzcwS42A3M0uMg93MLDEO9n5E0oWSVkvqkHRlvevZEUmTJU2vdx29Tb32i6RmSatr3a/tmQH1LsBqQ9Iw4GZgNPB7wDJJMyPi1fpWZmbV5mDvP44E3oiIDcAGSV8C9q5zTWZWAA/F9B9PA0Mk/VjSERHx44hYCyDpYkm/krRe0jVdD5B0ST5085KkySXL50o6X9K/SJpTsnyKpF9KWls61CPpBkmv5tPnK6i1SdJSSeskXZG30VY6FCFphqQLumtE0iRJr0h6WtK9XY+XNF3Sn0m6U9LzJetPlLQqr/+6fNl2QxGSpuZTc17fw5J+LekOSd3+P0k6J98/6yV9p2R55MNkayW9KOnYfPkpeT0vAJ/saadJOkTSkryu70t6XtJgSQdLeihfPlvSQfn6cyV9WdIzkjZJujBffrCkOZLWAdeVtD9I0t35Pm2XdFTpPpJ0pqSVvXWYr1+JCE/9ZAJGAj8CtgDX5suOBtYAhwKNwDrgKOD3gbVAU37fy8Af5I+ZC/wCOAcYnC87FngWGJK3sxY4GPhI3t8QYBjwLz3UOBl4E/gocDiwETgEOAhYT/YqowH4NfDhHtpan2/fnwF3lyyfnm/znwIfyZcNzdf/OHAAsAL4FNAMrC557NR8agYC+JO8nkXApB7qeQQ4ERiY76tj8uUB/FO+/A7glnz5c8AFwIeBdmB6D+3fnE9DgP8Afi9ffh/w+Xz+RuDbJb/HFfnv6UJgRb78duA7ZAd+3+3a/rztvwEETAH+b768GXgd+CnZ305Dvf/W+/vkI/Z+JCI6IuJi4HTgv0saD/wR8HBEvBwRnWTh/zwwAZgZES9FxMvAT4CJJc3dGREPRsTr+e3xZEH878AzwCBgFFnA/AL438B/Ai6uoNTZEfFCRPwKWAy0RsSvgZV5G+OBJyNicw/tbCEbbuyaSj0SET+IiE357VOBpyPi6Yh4DbgL+OMdtKmS+dci4icRsQX4Z+CUHuq5HBgL3EP2xHVQyX03RsRvyZ4g9pc0BDgM+Od8O/+ph7Zh++0dWLL8j4C/kvQq8EWy30uX70TE+q5+82VjyJ4IfwdMK2unjezJ/5tkw3td9iV78vhFvj+sjhzs/YSkL0q6ASAiFgP3kr2RCtuH1R+SHXWVi7L1FpV3AfxjRAyLiGFkR/pL8nA4iSz4/jPwM0n79FDu78rmu/p9APgs2SuF+3toA2BZ/pgpZEeqpcrrL1e+vV0OKZkvvX8vtq97O5IGA0vzdm8ke8Iq9UJJv11tR0R03d5p2yVWkT0ZPQ1cExFvl7R1fP57GQ5c0k2/Xet39fe7suVn5e0MA84oue+ViFhTQY1WAw72/uN54GJJB0raHziNLADmAGdJOjQ/SryN7KyZx4GzJR0m6RCyIYdZ3bT/RN7OiLydnwOj8nHYp4D5wPXACLLhme6Ml9Qk6VDgZOBn+fKfkIX6eODh7hqQdBjZK4hjImJ0RPx7D30uAFoknZDXP5ls6OQN4EBJH5Y0Ejiv5DFDJF0gaV/g/LyNnTmSLDynkQ2VtJbemT8Blt5+DViXj8s3kA2V9OQK4HMRcWhEfLdk+Wyg672Nr7D9UfiOnjCWABdK6hpyKW3nSkl7A+eSDb1YL+SzYvqJiHhM0n1kY6oBTIuI2QCSrgf+jezv4e8i4mf58mvJQlnA1yPimW7af0bSjcBCsmGAv4uI5Xk7c9h2ZHhr9HyK5TPAg2Rjvzd0HQlGxCuSXgFeLTka3ZmX85/rJP2GbEz7ynxYaUf1b5R0KfB/yIaRbouIR/L67yIL7V+RDaN0WUv2hHcb2SuDB7qpZznZk90rZPtoOdkro7ndPGYK2ZDQQLIn4Z48BDyeb++rwN9ExH3Al4E7JXWSHdX3NBz2deDHeRuPlSz/K+AfyIZiXmH70LdeRNte6Zn1bvkQzu3Ao3lgdbfuecBJEfE/JA0gG6NeGBHfrlItzcDciGiuRnt7Kt/GpWTvFWwBzgL+OiI+XtfCrC58xG59yXqyI+8vVrDuUuArktbnt58mOxpPUkS8J2k22ZDbQLKzia6vb1VWLz5iNzNLjN88NTNLjIPdzCwxDnYzs8T0ijdPDzzwwGhubq53GWZmfcqyZcs2RERj+fJeEezNzc20t7fXuwwzsz5F0ks7Wu6hGDOzxDjYzcwS42A3M0tMrxhjNzPbFb/97W/p6Ohgy5b+cYXghoYGRo4cycCBA3teGQe7mfVBHR0d7LfffjQ3N5NdhDJdEcHGjRvp6Ojg8MMPr+gxVR+KkTRA0v2S5udfPfZJSR2S5uXTqJ5bMTPbuS1btjB06NDkQx1AEkOHDt2lVydFjLF/FlgeEWPJLurfAtweEafl06oC+jSzfqY/hHqXXd3WIoZi/hV4JL+M6BCyLyq4QtJnyK6RfX74ymNmVkXN13b7vSu7bPU3z+r2/smTJ/P2229z//33M2nSJBoaGpg+fXpVa9gTVQ/2iHgLQNJisgvyPwa8FBEPS1pA9n2bc0sf09nZSWvrti+UaWtro62trdqlmSWr2sFWqqeQ669WrFgBwPLlyzn55JPrXM32qh7skoYCb5Fd8H8OcDzZN7sArGb7L/AFoLGx0Z88NbM+ZcCAAWzcuJG9996bzZs3c/7557Nu3TpaWlq47bbbmDp1Ku+99x5PPPEEb731FrNmzWLYsGE1qa2IMfargQsiYiuwGfifwCRJewHHkX1RgplZn9bS0sJ9991HS0sLjz76KMcddxzz589n3bp17x/Nr1q1innz5nHRRRcxZ86cmtVWRLDfBlwuaSHZt7icTfbdiIuBGRGxsoA+zcxq6sQTT2T69OmceOKJjBkzhhkzZjBu3DhefPFF1q5dC8Bll12GJA4++GDefffdmtVW9WCPiLURMT4ixkTEJfntcRHxiYj4y2r3Z2ZWD6NHj2bp0qWMHj2ahQsX8rWvfY25c+dy4403cuihhwIwaNCgutTmSwqYme2G5uZmjjrqKJqampgwYQKPPPIIp556KtOmTeOwww6ra2294jtPW1tbw2+e7r6izojw2RDA1MEFtv161Zrqb2fFPPfccxx99NH1LqOmdrTNkpZFRGv5uj5iNzNLjIPdzCwxDnYzs8Q42M3MEuNgNzNLjK/HbmZ9X7XPXurhjKWjjz6apUuXMmzYMF5++WU+9alPsWjRourWsAd8xG5mtotGjBjBwoULeeedd2hvb6e5ubneJW3HR+xmZruoqamJJ598krFjx/Lkk08yfPhwLrzwQtasWUNTUxPTp09n4sSJDB8+nM7OTrZu3UpLSws33XQTl156aeEXC/MRu5nZLmpubuapp55i4sSJPPXUUxxxxBEcc8wxzJ8/nyOPPJK77roLgG984xusWbOGmTNn8vOf/5xp06bV5GJhDnYzs13U1NTEggULOPPMM1mwYAHf+ta3GDNmDABjxoxh5crsWofNzc2MGDGCQYMGERGsWrWqJhcLc7Cbme2i5uZmhgwZQktLCwBXX331+2+eLlq0iGOPPXaHjxs1alRNLhbmMXbbuT5ynRSzWmtqauKjH/0oAwcOpKmpiUsuuYQvfOELjB07lqamJq677jruueeeDzzuyiuvZPLkyXzve9/jgAMO4N577y2kPl8ELAGFXQSs4aJC2gX6TrD3kSc3XwQsfb4ImJlZP+ZgNzNLjIPdzPqk3jCMXCu7uq0OdjPrcxoaGti4cWO/CPeIYOPGjTQ0NFT8GJ8VY2Z9zsiRI+no6KCzs7PepdREQ0MDI0eOrHh9B7uZ9TkDBw7k8MMPr3cZvZaHYszMElP1YJc0QNL9kuZLulNSg6SHJC2XdLckVbtPMzPbpogj9s8CyyNiLDAc+BLQEREnAAcAEwro08zMckUE+78Cfy9pADAEGA08lt83BzijgD7NzCxX9TdPI+ItAEmLgXXAUKDrs9NvAKPKH9PZ2Ulr67ZPxba1tdHW1lbt0ixRhX6cvvIzzMx6jaoHu6ShwFvAqWRH6B8Dui64MRjYUP6YxsZGfK0YM7PqKGIo5mrggojYCmwGbgIm5veNB54ooE8zM8sVEey3AZdLWghsBH4AHCJpBbAJmF1An2ZmlitijH0t2ZF5qbOr3Y+Zme2YP6BkZpYYB7uZWWIc7GZmiXGwm5klxsFuZpYYB7uZWWIc7GZmiXGwm5klxsFuZpYYB7uZWWIc7GZmiXGwm5klxsFuZpaYql/d0cysHgr9Jq1vnlVY20XwEbuZWWIc7GZmiXGwm5klxsFuZpYYB7uZWWIc7GZmiXGwm5klpurBrswPJS2S9KCksyV1SJqXT6Oq3aeZmW1TxBH7WGBARJwC7A/8Drg9Ik7Lp1UF9GlmZrkign098O18/t3853mSlkh6QJIK6NPMzHJVv6RARDwPIOlcYB/gBeCGiHhY0gLgdGBu6WM6OztpbW19/3ZbWxttbW3VLm3XTR1cULuvF9OumRWjj2VBIdeKkXQO8FXg02Thvjq/azVwUPn6jY2NtLe3F1GKmVm/U8Sbp8OAa4CzIuJN4CpgkqS9gOOAZ6vdp5mZbVPEGPtlwHBglqR5wGZgCrAYmBERKwvo08zMckWMsd8M3Fy2+KZq92NmZjvmDyiZmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlpiqB7syP5S0SNKDkgZJekjSckl3S1K1+zQzs20qCnZJl0o6T9K5kp6X9BfdrD4WGBARpwD7A5cDHRFxAnAAMGGPqzYzs52q9Ij9y8AMYDJwAvBfull3PfDtfP5dYCrwWH57DnDGrhZpZmaVG1DheluBzwBvAR8C3tvZihHxPICkc4F9gGXA6/ndbwCjyh/T2dlJa2vr+7fb2tpoa2urqLDmax+uaL3dsbqhsKbN+o6pgwts+/We17FdVmmwXwVMAr4OXJT/3ClJ5wBfBT4N/APQ9ZcxGNhQvn5jYyPt7e0VlmJmZt2paCgmIhZExFfIQvnOiPjpztaVNAy4BjgrIt4EZgMT87vHA0/sWclmZtadSt88vUTSs8BC4EpJf9vN6pcBw4FZkuYBA4FDJK0ANpEFvZmZFaTSoZivAB8HHo2IWyQt2dmKEXEzcHPZ4jt2sz4zM9tFlZ4V8zYwBkBSE/BmYRWZmdkeqTTY24A/Bw4CvgV8sbCKzMxsj1Q0FJOfwnhuwbWYmVkVVPrm6feLLsTMzKqj0qGYkPSJQisxM7OqqPSsmH2BxyXNInsjNSLi8uLKMjOz3VVpsF+fT2Zm1stV+snTl4CjgM8CR+a3zcysF6r0zdO/By4GtgAX57fNzKwXqnQo5uSIGJvP3yFpflEFmZnZnqk02F+TdDHZtWLGkF3zxczMeqFKT3e8FGgBvgMcn982M7NeqNJPnm6SdCuwBjgjIl4rtiwzM9tdlb55+gOyL9oAuEiSr9ZoZtZLVTrGfkxE/Gk+f4WkfyuqIDMz2zOVBvtGSf8VWAKcjC/ba2bWa/UY7JJOJPtWpOuBe4D/IHsj1czMeqFug13SPwJbI2KKJJEF+3PALfgyvmZmvVJPR+xHRMRpkg4HTo+I0QCSniq+NDMz2x09BXunpP8GfAb4a0n7AecBWwuvzMzMdktPpzteTPZG6TcjYgYwAvh94KKiCzMzs93TbbBHxOaIuCMiHs5vr4qIayNiXXePkzRQ0sx8/pOSOiTNy6dR1SvfzMzKVXq6Y8Uk7QssJrvMb5fbI+KmavdlZmYfVOm1YioWEe9ExPFAR8ni8yQtkfRAfnaNmZkVpOrBvgMvADdExEnAcOD0GvRpZtZvVX0oZgc2AY/n86uBg8pX6OzspLW19f3bbW1ttLW11aA0M7P01CLYrwJ+Ielu4Djgf5Wv0NjYSHt7ew1KMTNLXy2GYm4FppC9oTojIlbWoE8zs36rsCP2iPhY/nMdMK6ofszMbHu1OGI3M7MacrCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSXGwW5mlhgHu5lZYhzsZmaJcbCbmSWmkGCXNFDSzHy+QdJDkpZLuluSiujTzMwyVQ92SfsCy4AJ+aJLgI6IOAE4oGS5mZkVoOrBHhHvRMTxQEe+aDzwWD4/Bzij2n2amdk2tRhjHwq8ns+/AXykfIXOzk5aW1vfn6ZNm1aDsszM0jSgBn1sAAbn84Pz29tpbGykvb29BqWYmaWvFkfss4GJ+fx44Ika9Glm1m/VIth/BBwiaQWwiSzozcysIIUNxUTEx/KfvwHOLqofMzPbnj+gZGaWGAe7mVliHOxmZolxsJuZJcbBbmaWGAe7mVliHOxmZolxsJuZJcbBbmaWGAe7mVliHOxmZolxsJuZJcbBbmaWGAe7mVliHOxmZolxsJuZJcbBbmaWGAe7mVliHOxmZolxsJuZJcbBbmaWGAe7mVliahLskj4pqUPSvHwaVYt+zcz6owE17Ov2iLiphv2ZmfVLtRyKOU/SEkkPSFIN+zUz61dqFewvADdExEnAcOD00js7OztpbW19f5o2bVqNyjIzS0+thmI2AY/n86uBg0rvbGxspL29vUalmJmlrVZH7FcBkyTtBRwHPFujfs3M+p1aBfutwBRgMTAjIlbWqF8zs36nJkMxEbEOGFeLvszM+jt/QMnMLDEOdjOzxDjYzcwS42A3M0uMg93MLDEOdjOzxDjYzcwS42A3M0uMg93MLDEOdjOzxDjYzcwS42A3M0uMg93MLDEOdjOzxDjYzcwS42A3M0uMg93MLDEOdjOzxDjYzcwS42A3M0uMg93MLDGFB7ukBkkPSVou6W5JKrrPapm27N16l1BX/X37wfsAvA+g7+2DWhyxXwJ0RMQJwAHAhBr0WRV97ZdZbf19+8H7ALwPoO/tg1oE+3jgsXx+DnBGDfo0M+u3FBHFdiDNAv42Ih6XdAXwiYj4fNk6b7L9k0wnsKHQwipzIL2jjnrp79sP3gfgfQC9dx80RURj+cIBNeh4AzA4nx/MDnZOROxXgzrMzPqFWgzFzAYm5vPjgSdq0KeZWb9Vi2D/EXCIpBXAJrKgNzOzghQe7BHxm4g4OyKOj4jPRdGD+rtJmVskLZT0E0n7SBooaWa9a6uVHeyDD0n6oaRFkh6UVIuhu7rZyd/A/ZLmS7qz3vXVwo72Qb78zyU9Xu/6amEH++AcSR2S5uXTqHrX2BN/QGmbPwSaI2IM8P+AC4Bl9KHTM6ugfB9cCwyIiFOA/dk2pJaq8u2/EFgeEWOB4ZJa6llcjXzg/0BSEzC5rlXVVvk+2A+4PSJOy6dV9S2vZ0kfge2iccDcfP4WYGBE/EjSL+tWUe2NY/t9cAzw0/x23zqRd/eMY/vt3xfYkL9SGQK8UZeqamscZf8HwHeBvwCuqk9JNTeO7ffBBOA8SZ8BXgbO760jD118xL5NI/CGpM8BM4E/qXM99VC+D/4gIpZIOhfYB5hV1+qKV77950TEZmA+sD4iXqxrdbVRvg+uAJYDK+taVW2V74OhwA0RcRIwHDi9nsVVwkfs27wO7BcR35fUCbTWu6A6+MA+kHQO8FXg0xGxtb7lFa58+0+W9CHgVGCOpDMiIvWzusr3wSPAAuBMYJSkL0XErXWtsHgf+DsApuX3rQYOqldhlfIR+zbzgT/Or2VzQr2LqZMd7YNrgLMi4s36lVUz5dv/l8AF+RPaZrKhmdSV74OvR8RpwCRgWT8IddjBPgAmSdoLOA54tp7FVcLBvs2DwC+BJfSvN0xLle+Dvclees7Kzwa4vJ7F1UD59t8IXC5pIbCR9IeiwP8H8MF9MBWYAiwGZkRErx+WKvySAmZmVls+YjczS4yD3cwsMQ52M7PEONjNzBLjYDczS4yD3cwsMQ52M7PE/H9ysuwBEImUjQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "labels = ['G1', 'G2', 'G3', 'G4', 'G5']\n",
    "men_means = [20, 34, 30, 35, 27]\n",
    "women_means = [25, 32, 34, 20, 25]\n",
    "\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, men_means, width, label='Men')\n",
    "rects2 = ax.bar(x + width/2, women_means, width, label='Women')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('Scores')\n",
    "ax.set_title('Scores by group and gender')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "51908195",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    x = []\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"read request average response time:\"):\n",
    "                number = int(base_line.split()[5]) / 1e6\n",
    "                x.append(number)\n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return x\n",
    "\n",
    "\n",
    "base = get_trace_reference(\"base_stat.txt\")\n",
    "gc = get_trace_reference(\"gc_stat.txt\")\n",
    "labels = [\"HM_0\",\"HM_1\",\"PRN_0\",\"PRN_1\",\"PROJ_1\",\"PROJ_3\",\"PROJ_4\",\"PRXY_0\"]\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, base, width, label='BaseLine')\n",
    "rects2 = ax.bar(x + width/2, gc, width, label='LA-GC')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('读请求平均延迟（单位：毫秒）')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "plt.savefig(\"read_avg.png\", bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "db02857c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    x = []\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"write request average response time:\"):\n",
    "                number = int(base_line.split()[5]) / 1e6\n",
    "                x.append(number)\n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return x\n",
    "\n",
    "\n",
    "base = get_trace_reference(\"base_stat.txt\")\n",
    "gc = get_trace_reference(\"gc_stat.txt\")\n",
    "labels = [\"HM_0\",\"HM_1\",\"PRN_0\",\"PRN_1\",\"PROJ_1\",\"PROJ_3\",\"PROJ_4\",\"PRXY_0\"]\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, base, width, label='BaseLine')\n",
    "rects2 = ax.bar(x + width/2, gc, width, label='LA-GC')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('写请求平均延迟（单位：毫秒）')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "plt.savefig(\"write_avg.png\", bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "ee0d860b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    x = []\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"gc count:\"):\n",
    "                number = int(base_line.split()[2]) \n",
    "                x.append(number)\n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return x\n",
    "\n",
    "\n",
    "base = get_trace_reference(\"base_stat.txt\")\n",
    "gc = get_trace_reference(\"gc_stat.txt\")\n",
    "labels = [\"HM_0\",\"HM_1\",\"PRN_0\",\"PRN_1\",\"PROJ_1\",\"PROJ_3\",\"PROJ_4\",\"PRXY_0\"]\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, base, width, label='BaseLine')\n",
    "rects2 = ax.bar(x + width/2, gc, width, label='LA-GC')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('垃圾回收次数')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "plt.savefig(\"gc_count.png\", bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e3ba364a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#输入SSDsim的输出文件 trace out\n",
    "#输出trace名字和相应的read latency\n",
    "import numpy as np\n",
    "import seaborn as sns\n",
    "import sys\n",
    "from openpyxl import Workbook\n",
    "from openpyxl.utils import get_column_letter\n",
    "import pandas as pd\n",
    "import scipy\n",
    "import os\n",
    "import sys\n",
    "import matplotlib.pyplot as plt\n",
    "from pylab import * \n",
    "import math\n",
    "from numpy import cumsum\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#数据输入\n",
    "def get_trace_reference(filename):\n",
    "    \n",
    "    file_base = open(filename)\n",
    "    \n",
    "    flag=0\n",
    "    \n",
    "    x = []\n",
    "    \n",
    "    while 1:\n",
    "        \n",
    "        base_lines = file_base.readlines(100000)\n",
    "             \n",
    "        if (not base_lines):\n",
    "            \n",
    "            break \n",
    "            \n",
    "        for base_line in base_lines:\n",
    "\n",
    "            if str(base_line).startswith(\"gc average page move count:  \"):\n",
    "                number = int(base_line.split()[5]) \n",
    "                x.append(number)\n",
    "\n",
    "    file_base.close()\n",
    "    \n",
    "    return x\n",
    "\n",
    "\n",
    "base = get_trace_reference(\"base_stat.txt\")\n",
    "gc = get_trace_reference(\"gc_stat.txt\")\n",
    "labels = [\"HM_0\",\"HM_1\",\"PRN_0\",\"PRN_1\",\"PROJ_1\",\"PROJ_3\",\"PROJ_4\",\"PRXY_0\"]\n",
    "x = np.arange(len(labels))  # the label locations\n",
    "width = 0.35  # the width of the bars\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "rects1 = ax.bar(x - width/2, base, width, label='BaseLine')\n",
    "rects2 = ax.bar(x + width/2, gc, width, label='LA-GC')\n",
    "\n",
    "# Add some text for labels, title and custom x-axis tick labels, etc.\n",
    "ax.set_ylabel('迁移页数')\n",
    "ax.set_xticks(x)\n",
    "ax.set_xticklabels(labels)\n",
    "ax.legend()\n",
    "plt.savefig(\"tranfer.png\", bbox_inches = 'tight')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "88d78efe",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
